Core Language

Please visit the official Wolfram Language Reference for more details and examples on core symbols.

CreateDocument

CreateDocument[{expr1, expr2, ...}] creates an empty notebook and populates with the content. 
Use the option Visible->False to create the content and the notebook offscreen

NotebookOpen

NotebookOpen[nb] opens programmatically notebook nb given by RemoteNotebook object or a path

NotebookWrite

NotebookWrite[nb, expr] write expr as a cell, or group of cells to the notebook nb

NotebookClose

NotebookClose[nb] closes opened notebook nb

NotebookSave

NotebookSave[nb] or NotebookSave[nb, path] saves notebook nb to a file given by path or using the existing temporal path

NotebookEvaluate

NotebookEvaluate[nb] evaluates the initialization cells of the notebook and returns the result of the last Wolfram Language cell. 
Not recommended to use! Consider NotebookEvaluateAsync instead

Animate

Animate[expr_, {t, tmin, tmax}] animates expr starting from tmin to tmax with a default rate.

EvaluationNotebook

EvaluationNotebook[] gives the notebook in which this function is being evaluated. 

Let

A With-like construction that allows recursive assignments, like Let* in scheme

CreateType

CreateType[type, parent, init, {fields}] create type

Button

Button[label,action] represents a button that is labeled with label, and evaluates action whenever it is clicked. 

CellularAutomaton

CellularAutomaton[rule,init,t] generates a list representing the evolution of the cellular automaton with the specified rule from initial condition init for t steps. 

CellularAutomaton[rule,init] gives the result of evolving init for one step. 

CellularAutomaton[rule,init,{tspec,xspec,…}] gives only those parts of the evolution specified by tspec, xspec, etc. 

CellularAutomaton[rule,init,{t,All,…}] includes at each step all cells that could be affected over the course of t steps. 

CellularAutomaton[rule] is an operator form of CellularAutomaton that represents one step of evolution.

CreateFrontEndObject

CreateFrontEndObject[expr] uploads expression to frontend storage and creates a reference to it. On output it will try to evaluate it using WLJS Intepreter

Riffle

Riffle[{e1,e2,…},x] gives {e1,x,e2,x,…}. 

Riffle[{e1,e2,…},{x1,x2,…}] gives {e1,x1,e2,x2,…}. 

Riffle[list,x,n] yields a list in which every nth element is x. 

Riffle[list,x,{imin,imax,n}] yields a list in which x appears if possible at positions imin, imin+n, imin+2n, … , imax. 

SystemDialogInput

SystemDialogInput["type"] brings up an interactive system dialog and returns the value chosen in the dialog. 

SystemDialogInput["type",init] uses init as the initial setting in the dialog.

ChoiceDialog

ChoiceDialog[expr] puts up a standard choice dialog that displays expr together with OK and Cancel buttons, and returns True if OK is clicked and False if Cancel is clicked.

ChoiceDialog[expr,{lbl1->val1,lbl2->val2,…}] includes buttons with labels lbli, and returns the corresponding vali for the button clicked.

TabView

TabView[{lbl1->expr1, lbl2->expr2, …}] represents an object in which clicking the tab with label lbli displays expri. 

TabView[{lbl1->expr1,lbl2->expr2,…},i] makes the ith tab be the one currently selected.

TabView[{{v1,lbl1->expr1},{v2,lbl2->expr2},…},v] associates values vi with successive tabs, and makes the tab with value v be the one currently selected. 

TabView[{expr1,expr2,…}] takes the tab labels to be successive integers.

StringTake

StringTake["string",n] gives a string containing the first n characters in "string". 

StringTake["string",-n] gives the last n characters in "string". 

StringTake["string",{n}] gives the nth character in "string". 

StringTake["string",{m,n}] gives characters m through n in "string". 

StringTake["string",{spec1,spec2,…}] gives a list of the substrings specified by the speci.

StringTake[{s1,s2,…},spec] gives the list of results for each of the si.

StringDrop

StringDrop["string",n] gives "string" with its first n characters dropped. 

StringDrop["string",-n] gives "string" with its last n characters dropped. 

StringDrop["string",{n}] gives "string" with its nth character dropped. 

StringDrop["string",{m,n}] gives "string" with characters m through n dropped. 

StringDrop[{s1,s2,…},spec] gives the list of results for each of the si.

AnimatedImage

AnimatedImage[{image1,image2,…}] generates an animation whose frames are the successive imagei. 

AnimatedImage[file] represents an animated image from file.

ByteCount

ByteCount[expr] gives the number of bytes used internally by the Wolfram System to store expr. 

Sum

Sum[f,{i,imax}] evaluates the sum ∑+i=1%imaxf. 

Sum[f,{i,imin,imax}] starts with i=imin. 

Sum[f,{i,imin,imax,di}] uses steps di. 

Sum[f,{i,{i1,i2,…}}] uses successive values i1, i2, ….

Sum[f,{i,imin,imax},{j,jmin,jmax},…] evaluates the multiple sum ∑+i=imin%imax∑+j=jmin%jmax…f. 

Sum[f,i] gives the indefinite sum ∑+if.

Product

Product[f,{i,imax}] evaluates the product ∏+i=1%imaxf. 

Product[f,{i,imin,imax}] starts with i=imin. 

Product[f,{i,imin,imax,di}] uses steps di. 

Product[f,{i,{i1,i2,…}}] uses successive values i1, i2, ….

Product[f,{i,imin,imax},{j,jmin,jmax},…] evaluates the multiple product ∏+i=imin%imax∏+j=jmin%jmax… f. 

Product[f,i] gives the indefinite product ∏+if.

Differences

Differences[list] gives the successive differences of elements in list. 

Differences[list,n] gives the nth differences of list. 

Differences[list,n,s] gives the differences of elements step s apart.

Differences[list,{n1,n2,…}] gives the successive nkth differences at level k in a nested list. 

Drop

Drop[list,n] gives list with its first n elements dropped. 

Drop[list,-n] gives list with its last n elements dropped. 

Drop[list,{n}] gives list with its nth element dropped. 

Drop[list,{m,n}] gives list with elements m through n dropped. 

Drop[list,{m,n,s}] gives list with elements m through n in steps of s dropped. 

Drop[list,seq1,seq2,…] gives a nested list in which elements specified by seqi have been dropped at level i in list. 

NotebookDirectory

NotebookDirectory[] gives the directory of the current evaluation notebook. 

NotebookDirectory[nb] gives the directory for the notebook specified by nb. 

EvaluationCell

EvaluationCell[] returns a CellObject corresponding to the cell in which this function is being evaluated.

SystemOpen

SystemOpen["target"] opens the specified file, URL, or other target with the associated program on your computer system.

Annotation

Annotation[expr,data] represents an expression expr, with annotation data.

Annotation[expr,data,"type"] specifies the type of annotation being given.

Annotation[items,key->value] associates key->value pairs with items in objects such as Graph, MeshRegion etc. 

Integrate

Integrate[f,x] gives the indefinite integral ∫f dx. 

Integrate[f,{x,xmin,xmax}] gives the definite integral ∫xminxmax f dx. 

Integrate[f,{x,xmin,xmax},{y,ymin,ymax},…] gives the multiple integral ∫xminxmaxdx∫yminymaxdy … f. 

Integrate[f,{x,y,…}∈reg] integrates over the geometric region reg.

TableForm

TableForm[list] prints with the elements of list arranged in an array of rectangular cells. 

Item

Item[expr,options] represents an item within constructs such as Grid, Overlay, and Manipulate that displays with expr as the content, and with the specified options applied to the region containing expr. 

ToExpression

ToExpression[input] gives the expression obtained by interpreting strings or boxes as Wolfram Language input. 

ToExpression[input,form] uses interpretation rules corresponding to the specified form. 

ToExpression[input,form,h] wraps the head h around the expression produced before evaluating it. 

MakeBoxes

MakeBoxes[expr,form] is the low‐level function used in Wolfram System sessions to convert expressions into boxes. 

MakeBoxes[expr] is the function to convert expr to StandardForm boxes.

Transpose

Transpose[list] transposes the first two levels in list. 

Transpose[list,{n1,n2,…}] transposes list so that the kth level in list is the nkth level in the result. 

Transpose[list,mn] transposes levels m and n in list, leaving all other levels unchanged.

Transpose[list,k] cycles the levels in list k positions to the right. 

Series

Series[f,{x,x0,n}] generates a power series expansion for f about the point x=x0 to order (x-x0)n, where n is an explicit integer. 

Series[f,x->x0] generates the leading term of a power series expansion for f about the point x=x0. 

Series[f,{x,x0,nx},{y,y0,ny},…] successively finds series expansions with respect to x, then y, etc. 

AASTriangle

AASTriangle[α,β,a] returns a filled triangle with angles α and β and side length a, where a is adjacent to one angle only.

AbelianGroup

AbelianGroup[{n1,n2,…}] represents the direct product of the cyclic groups of degrees n1,n2,….

Abort

Abort[] generates an interrupt to abort a computation. 

AbortKernels

AbortKernels[] aborts evaluations running in all parallel subkernels.

AbortProtect

AbortProtect[expr] evaluates expr, saving any aborts until the evaluation is complete. 

Above

Above is a symbol that represents the region above an object for purposes of placement.

Abs

Abs[z] gives the absolute value of the real or complex number z. 

AbsArg

AbsArg[z] gives the list {Abs[z],Arg[z]} of the number z.

AbsArgPlot

AbsArgPlot[f,{x,xmin,xmax}] generates a plot of Abs[f] colored by Arg[f] as a function of x∈ from xmin to xmax.

AbsArgPlot[{f1,f2,…},{x,xmin,xmax}] plots several functions.

AbsArgPlot[{…,w[fi],…},…] plots fi with features defined by the symbolic wrapper w.

AbsArgPlot[…,{x}∈reg] takes the variable x to be in the geometric region reg.

AbsoluteCorrelationFunction

AbsoluteCorrelationFunction[data,hspec] estimates the absolute correlation function at lags hspec from data.

AbsoluteCorrelationFunction[proc,hspec] represents the absolute correlation function at lags hspec for the random process proc. 

AbsoluteCorrelationFunction[proc,s,t] represents the absolute correlation function at times s and t for the random process proc. 

AbsoluteCurrentValue

AbsoluteCurrentValue[item] gives the absolute current value of item at a location in the Wolfram System and interface. 

AbsoluteCurrentValue[{item,spec}] gives the absolute current value for the feature of item specified by spec.

AbsoluteCurrentValue[obj,item] gives the absolute current value of item associated with the object obj. 

AbsoluteCurrentValue[{obj1,obj2,…},item] gives a list of the absolute current values associated with each of the obji.

AbsoluteDashing

AbsoluteDashing[{d1,d2,…}] is a graphics directive which specifies that lines which follow are to be drawn dashed, with successive segments having absolute lengths d1, d2, … (repeated cyclically). 

AbsoluteDashing[d] is equivalent to AbsoluteDashing[{d,d}]. 

AbsoluteDashing[{d1,d2,…},offset] offsets the dashes by offset.

AbsoluteDashing[{d1,d2,…},offset,capform] sets the CapForm for individual dashes to capform. 

AbsoluteFileName

AbsoluteFileName["name"] gives the full absolute version of the name for a file in your filesystem.

AbsoluteOptions

AbsoluteOptions[obj] gives the absolute settings of options used by the given object.

AbsoluteOptions[obj,name] gives the absolute setting for the option name. 

AbsoluteOptions[obj,{name1,name2,…}] gives a list of the absolute settings for the options namei. 

AbsolutePointSize

AbsolutePointSize[d] is a graphics directive which specifies that points which follow are to be shown if possible as circular regions with absolute diameter d. 

AbsoluteThickness

AbsoluteThickness[d] is a graphics directive which specifies that lines which follow are to be drawn with absolute thickness d. 

AbsoluteTime

AbsoluteTime[] gives the total number of seconds since the beginning of January 1, 1900, in your time zone.

AbsoluteTime[date] gives the absolute time specification corresponding to the given date specification.

AbsoluteTiming

AbsoluteTiming[expr] evaluates expr, returning a list of the absolute number of seconds in real time that have elapsed, together with the result obtained. 

AcceptanceThreshold

AcceptanceThreshold is an option that specifies the minimum threshold at which a result is considered acceptable.

AccountingForm

AccountingForm[expr] prints with all numbers in expr given in standard accounting notation. 

AccountingForm[expr,n] prints with numbers given to n‐digit precision. 

Accumulate

Accumulate[list] gives a list of the successive accumulated totals of elements in list. 

Accuracy

Accuracy[x] gives the effective number of digits to the right of the decimal point in the number x. 

AccuracyGoal

AccuracyGoal is an option for various numerical operations which specifies how many effective digits of accuracy should be sought in the final result. 

Activate

Activate[expr] replaces all instances of Inactive[f] in expr with f.

Activate[expr,patt] replaces only instances of Inactive[f] for which f matches the pattern patt.

ActiveClassification

ActiveClassification[f,{conf1,conf2,…}] gives an object representing the result of active classification obtained by using the function f to determine classes for the example configurations confi. 

ActiveClassification[f,reg] generates configurations within the region specified by reg.

ActiveClassification[f,sampler] generates configurations by applying the function sampler.

ActiveClassification[f,{conf1,conf2,…}->nsampler] applies the function nsampler to successively generate configurations starting from one of the confi.

ActiveClassificationObject

ActiveClassificationObject[…] represents the result of an ActiveClassification process.

ActivePrediction

ActivePrediction[f,{conf1,conf2, …}] gives an object representing the result of active prediction obtained by using the function f to determine values for the example configurations confi.

ActivePrediction[f,reg] generates configurations within the region specified by reg.

ActivePrediction[f,sampler] generates configurations by applying the function sampler.

ActivePrediction[f,{conf1,conf2,…}->nsampler] applies the function nsampler to successively generate configurations starting from one of the confi.

ActivePredictionObject

ActivePredictionObject[…] represents the result of an ActivePrediction process.

AddTo

x+=dx adds dx to x and returns the new value of x. 

AddToSearchIndex

AddToSearchIndex[obj,content] adds the specified content to the existing search index object obj. 

AddToSearchIndex[obj,{content1,…}] adds all the contenti to obj.

AdjacencyGraph

AdjacencyGraph[amat] gives the graph with adjacency matrix amat.

AdjacencyGraph[{v1,v2,…},amat] gives the graph with vertices vi and adjacency matrix amat.

AdjacencyList

AdjacencyList[g,v] gives a list of vertices adjacent to vertex v.

AdjacencyList[g,patt] gives a list of vertices adjacent to vertices that match the pattern patt.

AdjacencyList[g,patt,d] gives a list of vertices that are at distance at most d.

AdjacencyList[{v->w,…},…] uses rules v->w to specify the graph g. 

AdjacencyMatrix

AdjacencyMatrix[g] gives the vertex–vertex adjacency matrix of the graph g.

AdjacencyMatrix[{v->w,…}] uses rules v->w to specify the graph g. 

Adjugate

Adjugate[m] gives the adjugate of a square matrix m.

AffineHalfSpace

AffineHalfSpace[{p1,…,pk+1},w] represents AffineSpace[{p1,…,pk+1}] extended in the direction w.

AffineHalfSpace[p,{v1,…,vk},w] represents AffineSpace[p,{v1,…,vk}] extended in the direction w.

AffineSpace

AffineSpace[{p1,…,pk+1}] represents the affine space passing through the points pi.

AffineSpace[p,{v1,…,vk}] represents the affine space passing through p in the directions vi.

AffineStateSpaceModel

AffineStateSpaceModel[{a,b,c,d},x] represents the affine state-space model x'(t)a(x(t))+b(x(t)).u(t), y(t)=c(x(t))+d(x(t)).u(t).

AffineStateSpaceModel[sys] gives an affine state-space model corresponding to the system model sys.

AffineStateSpaceModel[eqns,{{x1,x10},…},{{u1,u10},…},{g1,…},t] gives the affine state-space model obtained by Taylor input linearization about the dependent variable xi at xi0 and input uj at uj0 of the differential equations eqns with outputs gi and independent variable t.

AffineTransform

AffineTransform[m] gives a TransformationFunction that represents an affine transform that maps r to m.r. 

AffineTransform[{m,v}] gives an affine transform that maps r to m.r+v.

After

After is a symbol that represents the region after an object for purposes of placement.

AggregatedEntityClass

AggregatedEntityClass[class,"prop"->f] represents an entity class containing a single entity with the property prop whose value is the result of applying the function f to the whole specified entity class.

AggregatedEntityClass[class,{prop1->f1,prop2->f2,…}] constructs multiple properties propi obtained by applying fi to class.

AggregatedEntityClass[class,propspec,gprop] forms groups of elements of class according to their values of the property gprop, then generates an entity class with an entity for each of these groups. 

AggregatedEntityClass[class,propspec,"pname"->f] forms groups according to the values obtained by applying the entity function f, with the resulting property named pname.

AggregatedEntityClass[class,propspec,{gspec1,gspec2,…}] forms groups for which the set of values defined by the gspeci is distinct. 

AggregationLayer

AggregationLayer[f] represents a layer that aggregates an array of arbitrary rank into a vector, using the function f.

AggregationLayer[f,n] aggregates an array at level n.

AggregationLayer[f,n1;;n2] aggregates an array at levels n1 through n2.

AggregationLayer[f,{n1,n2,…}] aggregates an array at levels n1,n2,….

AiryAi

AiryAi[z] gives the Airy function Ai(z). 

AiryAiPrime

AiryAiPrime[z] gives the derivative of the Airy function Ai′(z). 

AiryAiZero

AiryAiZero[k] represents the kth zero of the Airy function Ai(x).

AiryAiZero[k,x0] represents the kth zero less than x0.

AiryBi

AiryBi[z] gives the Airy function Bi(z). 

AiryBiPrime

AiryBiPrime[z] gives the derivative of the Airy function Bi′(z). 

AiryBiZero

AiryBiZero[k] represents the kth zero of the Airy function Bi(x).

AiryBiZero[k,x0] represents the kth zero less than x0.

AlgebraicIntegerQ

AlgebraicIntegerQ[a] yields True if a is an algebraic integer, and yields False otherwise.

AlgebraicNumberDenominator

AlgebraicNumberDenominator[a] gives the smallest positive integer n such that n a is an algebraic integer.

AlgebraicNumberNorm

AlgebraicNumberNorm[a] gives the norm of the algebraic number a.

AlgebraicNumberPolynomial

AlgebraicNumberPolynomial[a,x] gives the polynomial in x corresponding to the AlgebraicNumber object a.

AlgebraicNumberTrace

AlgebraicNumberTrace[a] gives the trace of the algebraic number a.

AlgebraicRulesData

AlgebraicRulesData is an object returned by AlgebraicRules. Its OutputForm appears to be a list of rules, but the rules will be used algebraically rather than syntactically by Replace and related functions.

Algebraics

Algebraics represents the domain of algebraic numbers, as in x∈Algebraics. 

AlgebraicUnitQ

AlgebraicUnitQ[a] yields True if a is an algebraic unit, and yields False otherwise.

AlignmentPoint

AlignmentPoint is an option which specifies how objects should by default be aligned when they appear in Inset.

All

All is a setting used for certain options. In Part and related functions, All specifies all parts at a particular level. 

AllowedFrequencyRange

AllowedFrequencyRange is an option for audio and signal processing functions that specifies the range of frequencies of interest.

AllowLooseGrammar

AllowLooseGrammar is an option for GrammarRules and related functions that specifies whether grammatical "fluff" should automatically be ignored in applying grammar rules.

AllTrue

AllTrue[{e1,e2,…},test] yields True if test[ei] is True for all of the ei.

AllTrue[expr,test,level] tests parts of expr at level level.

AllTrue[test] represents an operator form of AllTrue that can be applied to an expression.

Alphabet

Alphabet[] gives a list of the lowercase letters a through z in the English alphabet.

Alphabet[type] gives the alphabet for the language or class type.

Alphabet[type,prop] gives the alphabet defined by prop for the language or class type .

AlphabeticOrder

AlphabeticOrder["string1","string2"] gives 1 if "string1" appears before "string2" in alphabetical order, -1 if it is after, and 0 if it is identical. 

AlphabeticOrder["string1","string2",lang] uses an ordering suitable for the language lang.

AlphabeticOrder[lang] represents an operator form that compares strings when applied to "string1", "string2".

AlphabeticSort

AlphabeticSort[list] sorts the elements of list into alphabetical order.

AlphabeticSort[list,lang] sorts using an ordering suitable for the language lang.

AlphaChannel

AlphaChannel[color] returns the opacity of color.

AlphaChannel[image] returns the alpha channel of image.

AlphaChannel[video] returns a video containing the alpha channel of the frames in video.

AlternateImage

AlternateImage is an option to CDFInformation that specifies an image that should be used if the plugin is not available.

AlternatingFactorial

AlternatingFactorial[n] gives the alternating factorial af(n).

AlternatingGroup

AlternatingGroup[n] represents the alternating group of degree n.

AlternativeHypothesis

AlternativeHypothesis is an option for hypothesis testing functions like LocationTest that specifies the alternative hypothesis.

Alternatives

p1|p2|… is a pattern object that represents any of the patterns pi. 

AmbiguityFunction

AmbiguityFunction is an option for SemanticInterpretation, Interpreter, and related functions that specifies how to resolve ambiguities generated during semantic interpretation.

AmbiguityList

AmbiguityList[{expr1,expr2,…}] represents possible results derived from an ambiguous semantic interpretation.

AmbiguityList[{expr1,expr2,…},"string"] represents possible results from semantic interpretation of an input string.

AmbiguityList[{expr1,expr2,…},"string",{assoc1,assoc2,…}] includes a sequence of associations giving details of the interpretations used to obtain the expri.

Analytic

Analytic is an option for Limit and Series. With Analytic -> True, unrecognized functions are treated as analytic, and processed using Taylor series expansions; with Analytic -> False, Taylor series are not used unless the function is recognized as analytic.

AnatomyData

AnatomyData[entity,property] gives the value of the specified property for the anatomical structure entity.

AnatomyData[{entity1,entity2,…},property] gives a list of property values for the specified anatomical structure entities.

AnatomyData[entity,property,annotation] gives the specified annotation associated with the given property.

AnatomyPlot3D

AnatomyPlot3D[primitives,options] represents a three-dimensional graphical image that works with anatomical entities as well as standard 3D graphics primitives and directives.

AnchoredSearch

AnchoredSearch is an option for Find and FindList that specifies whether the text searched for must be at the beginning of a record. 

And

e1&&e2&&… is the logical AND function. It evaluates its arguments in order, giving False immediately if any of them are False, and True if they are all True. 

AndersonDarlingTest

AndersonDarlingTest[data] tests whether data is normally distributed using the Anderson–Darling test.

AndersonDarlingTest[data,dist] tests whether data is distributed according to dist using the Anderson–Darling test.

AndersonDarlingTest[data,dist,"property"] returns the value of "property".

AngerJ

AngerJ[ν,z] gives the Anger function Jν(z).

AngerJ[ν,μ,z] gives the associated Anger function Jνμ(z).

AngleBisector

AngleBisector[{q1,p,q2}] gives the bisector of the interior angle at p formed by the triangle with vertex points p, q1 and q2.

AngleBisector[{q1,p,q2},"type"] gives the angle bisector of the specified type.

AngleBracket

AngleBracket[x,y,…] displays as 〈x,y,…〉.

AnglePath

AnglePath[{θ1,θ2,θ3,…}] gives the list of 2D coordinates corresponding to a path that starts at {0,0}, then takes a series of steps of unit length at successive relative angles θi. 

AnglePath[{{r1,θ1},{r2,θ2},{r3,θ3},…}] takes successive steps of lengths ri. 

AnglePath[θ0,{step1,step2,…}] starts at angle θ0 with respect to the x axis.

AnglePath[{x,y},{step1,step2,…}] starts at the point {x,y} with initial angle 0 with respect to the x axis.

AnglePath[{{x,y},θ0},{step1,step2,…}] starts at {x,y} with initial angle θ0 with respect to the x axis.

AnglePath[{{x,y},{dx,dy}},{step1,step2,…}] takes the first step to go from {x,y} to {x+dx,y+dy}.

AnglePath[init,steps,form] returns at each step the data of the form specified by form.

AnglePath3D

AnglePath3D[{{α1,β1,γ1},{α2,β2,γ2},…}] gives the list of 3D coordinates of a path of an object that starts at {0,0,0}, then takes a series of steps of unit length, each in the direction of the x axis obtained after successive rotation of the object by the Euler angles αi, βi, γi.

AnglePath3D[{{α1,β1},{α2,β2},…}] assumes the Euler angles γi to be 0.

AnglePath3D[{mat1,mat2,…}] takes the successive rotations to be specified by the 3D rotation matrices mati. 

AnglePath3D[{{r1,rot1},{r2,rot2},…}] takes successive steps of length ri with Euler angles or rotation matrices specified by roti.

AnglePath3D[{x0,y0,z0},steps] starts at the point {x0,y0,z0}.

AnglePath3D[{rot0},steps] starts in the x axis direction specified by rotating the object according to Euler angles or rotation matrix rot0.

AnglePath3D[{{x0,y0,z0},rot0},steps] starts at point {x0,y0,z0} with the x axis direction specified by rot0.

AnglePath3D[init,steps,form] returns at each step the data of the form specified by form.

AngleVector

AngleVector[θ] gives the list representing the 2D unit vector at angle θ relative to the x axis.

AngleVector[{r,θ}] gives the list representing the 2D vector of length r at angle θ.

AngleVector[{x,y},θ] gives the result of starting from the point {x,y}, then going a unit distance at angle θ.

AngleVector[{x,y},{r,θ}] gives the result of starting from the point {x,y}, then going distance r at angle θ.

AnimationRate

AnimationRate is an option for Animate and Animator that specifies at what rate an animation should run, in units per second. 

AnimationRepetitions

AnimationRepetitions is an option to Animate and related functions that specifies how many times the animation they create runs before stopping.

Annuity

Annuity[p,t] represents an annuity of fixed payments p made over t periods.

Annuity[p,t,q] represents a series of payments occurring at time intervals q.

Annuity[{p,{pinitial,pfinal}},t,q] represents an annuity with the specified initial and final payments.

AnnuityDue

AnnuityDue[p,t] represents an annuity due of fixed payments p made over t periods.

AnnuityDue[p,t,q] represents a series of payments occurring at time intervals q.

AnnuityDue[{p,{pinitial,pfinal}},t,q] represents an annuity due with the specified initial and final payments.

Annulus

Annulus[{x,y},{rinner,router}] represents an annulus centered at {x,y} with inner radius rinner and outer radius router.

Annulus[{x,y},{rinner,router},{θ1,θ2}] represents an annulus from angle θ1 to θ2.

AnomalyDetection

AnomalyDetection[{example1,example2,…}] generates an AnomalyDetectorFunction[…] based on the examples given.

AnomalyDetection[LearnedDistribution[…]] generates an anomaly detector based on the given distribution.

AnomalyDetection[<|True->{example11,example12,…},False->{example21,…}|>] can be used to indicate which examples should be considered anomalous.

AnomalyDetector

AnomalyDetector is an option for functions such as Classify that specifies an anomaly detector for them to include.

AnomalyDetectorFunction

AnomalyDetectorFunction[…] represents a function generated by AnomalyDetection for detecting whether data is anomalous or not.

Anonymous

Anonymous represents an option or other value that indicates the absence of a name.

Antialiasing

Antialiasing is an option that specifies whether antialiasing should be done.

Antihermitian

Antihermitian[{1,2}] represents the symmetry of an antihermitian matrix.

AntihermitianMatrixQ

AntihermitianMatrixQ[m] gives True if m is explicitly antihermitian, and False otherwise.

Antisymmetric

Antisymmetric[{s1,…,sn}] represents the symmetry of a tensor that is antisymmetric in the slots si.

AntisymmetricMatrixQ

AntisymmetricMatrixQ[m] gives True if m is explicitly antisymmetric, and False otherwise.

Antonyms

Antonyms["word"] returns the antonyms associated with the specified word.

AnyOrder

AnyOrder[p1,p2,…] is a grammar rules pattern object that represents a sequence of elements matching p1, p2, … in any order.

AnySubset

AnySubset[{c1,c2,…}] represents an element in an interpreter or form that accepts any subset of the choices ci. 

AnySubset[{lab1->c1,lab2->c2,…}] accepts any subset of the labi, yielding the corresponding ci as results.

AnySubset[EntityClass["type","class"]] accepts any subset of the entities in the specified entity class.

AnySubset[choices,max] allows at most max choices to be selected.

AnySubset[choices,{min,max}] allows at least min and at most max choices to be selected.

AnyTrue

AnyTrue[{e1,e2,…},test] yields True if test[ei] is True for any of the ei.

AnyTrue[expr,test,level] tests parts of expr at level level.

AnyTrue[test] represents an operator form of AnyTrue that can be applied to an expression.

Apart

Apart[expr] rewrites a rational expression as a sum of terms with minimal denominators. 

Apart[expr,var] treats all variables other than var as constants. 

ApartSquareFree

ApartSquareFree[expr] rewrites a rational expression as a sum of terms whose denominators are powers of square-free polynomials. 

ApartSquareFree[expr,var] treats all variables other than var as constants. 

APIFunction

APIFunction[{name1->type1,name2->type2,…},fun] represents an API with parameters namei that evaluates the function fun whenever it is called. The function fun is applied to <|name1->val1,name2->val2,…|>, where the vali are the settings for the parameters, interpreted as being of types typei.

APIFunction[{name1->type1->default1,…},fun] takes the value of the parameter namei to be defaulti if it is not specified when the API is called.

APIFunction[params,fun,fmt] specifies that the result from applying fun should be returned in format fmt.

APIFunction[params,fun,{fmt,rform}] specifies that the result should be returned as a response of the form rform.

APIFunction[params,fun,{fmt,rform,failfmt}] specifies that in the event of failure, the result should be returned in format failfmt.

Appearance

Appearance is an option for displayed objects such as Button and Slider that specifies the general type of appearance they should have. 

AppearanceElements

AppearanceElements is an option for functions like Manipulate that specifies what elements should be included in the displayed form of the object generated.

AppearanceRules

AppearanceRules is an option for form and page generation functions that specifies the overall appearance of the generated object.

AppellF1

AppellF1[a,b1,b2,c,x,y] is the Appell hypergeometric function of two variables F1(a;b1,b2;c;x,y). 

Append

Append[expr,elem] gives expr with elem appended. 

Append[elem] represents an operator form of Append that can be applied to an expression.

AppendLayer

AppendLayer[] represents a net layer that takes an input array and appends another array to it.

AppendTo

AppendTo[x,elem] appends elem to the value of x, and resets x to the result. 

Application

fg or Application[f,g] represents the formal application of f to g.

Apply

f@@expr or Apply[f,expr] replaces the head of expr by f. 

f@@@expr or Apply[f,expr,{1}] replaces heads at level 1 of expr by f.

Apply[f,expr,levelspec] replaces heads in parts of expr specified by levelspec. 

Apply[f] represents an operator form of Apply that can be applied to an expression.

ApplyTo

ApplyTo[x,f] or x//=f computes f[x] and resets x to the result.

ArcCos

ArcCos[z] gives the arc cosine cos-1(z) of the complex number z. 

ArcCosh

ArcCosh[z] gives the inverse hyperbolic cosine cosh-1(z) of the complex number z. 

ArcCot

ArcCot[z] gives the arc cotangent cot-1(z) of the complex number z. 

ArcCoth

ArcCoth[z] gives the inverse hyperbolic cotangent coth-1(z) of the complex number z. 

ArcCsc

ArcCsc[z] gives the arc cosecant csc-1(z) of the complex number z. 

ArcCsch

ArcCsch[z] gives the inverse hyperbolic cosecant csch-1(z) of the complex number z. 

ArcCurvature

ArcCurvature[{x1,…,xn},t] gives the curvature of the parametrized curve whose Cartesian coordinates xi are functions of t.

ArcCurvature[{x1,…,xn},t,chart] interprets the xi as coordinates in the specified coordinate chart.

ARCHProcess

ARCHProcess[κ,{α1,…,αq}] represents an autoregressive conditionally heteroscedastic process of order q, driven by a standard white noise.

ARCHProcess[κ,{α1,…,αq},init] represents an ARCH process with initial data init.

ArcLength

ArcLength[reg] gives the length of the one-dimensional region reg.

ArcLength[{x1,…,xn},{t,tmin,tmax}] gives the length of the parametrized curve whose Cartesian coordinates xi are functions of t.

ArcLength[{x1,…,xn},{t,tmin,tmax},chart] interprets the xi as coordinates in the specified coordinate chart.

ArcSec

ArcSec[z] gives the arc secant sec-1(z) of the complex number z. 

ArcSech

ArcSech[z] gives the inverse hyperbolic secant sech-1(z) of the complex number z. 

ArcSin

ArcSin[z] gives the arc sine sin-1(z) of the complex number z. 

ArcSinDistribution

ArcSinDistribution[{xmin,xmax}] represents the arc sine distribution supported between xmin and xmax.

ArcSinDistribution[] represents the arc sine distribution supported between zero and one.

ArcSinh

ArcSinh[z] gives the inverse hyperbolic sine sinh-1(z) of the complex number z. 

ArcTan

ArcTan[z] gives the arc tangent tan-1(z) of the complex number z. 

ArcTan[x,y] gives the arc tangent of y/x, taking into account which quadrant the point (x,y) is in. 

ArcTanh

ArcTanh[z] gives the inverse hyperbolic tangent tanh-1(z) of the complex number z. 

Area

Area[reg] gives the area of the two-dimensional region reg.

Area[{x1,…,xn},{s,smin,smax},{t,tmin,tmax}] gives the area of the parametrized surface whose Cartesian coordinates xi are functions of s and t.

Area[{x1,…,xn},{s,smin,smax},{t,tmin,tmax},chart] interprets the xi as coordinates in the specified coordinate chart.

Arg

Arg[z] gives the argument of the complex number z. 

ArgMax

ArgMax[f,x] gives a position xmax at which f is maximized.

ArgMax[f,{x,y,…}] gives a position {xmax,ymax,…} at which f is maximized.

ArgMax[{f,cons},{x,y,…}] gives a position at which f is maximized subject to the constraints cons. 

ArgMax[…,x∈rdom] constrains x to be in the region or domain rdom.

ArgMax[…,…,dom] constrains variables to the domain dom, typically Reals or Integers.

ArgMin

ArgMin[f,x] gives a position xmin at which f is minimized.

ArgMin[f,{x,y,…}] gives a position {xmin,ymin,…} at which f is minimized.

ArgMin[{f,cons},{x,y,…}] gives a position at which f is minimized subject to the constraints cons. 

ArgMin[…,x∈rdom] constrains x to be in the region or domain rdom.

ArgMin[…,…,dom] constrains variables to the domain dom, typically Reals or Integers.

ArgumentCountQ

ArgumentCountQ[head, len, min, max] tests whether the number len of arguments of a function head is between min and max.

ArgumentCountQ[head,len,{m1,m2,…,mi}] tests whether the number len of arguments of a function head is one of the mi.

ArgumentsOptions

ArgumentsOptions[f[args],n] tries to separate args into a list of n positional arguments followed by a list of valid options for f.

ArgumentsOptions[f[args],{min,max}] requires the number of positional arguments to be between min and max.

ArgumentsOptions[f[args],spec,assoc] modifies the behavior based on the information in the association assoc.

ArithmeticGeometricMean

ArithmeticGeometricMean[a,b] gives the arithmetic‐geometric mean of a and b. 

Around

Around[x,δ] represents an approximate number or quantity with a value around x and an uncertainty δ.

Around[x,{δ-,δ+}] represents a number or quantity with a value around x and asymmetric uncertainties δ-, δ+.

Around[dist] gives an approximate number or quantity around the mean of the distribution dist, with an uncertainty corresponding to the standard deviation of the distribution.

Around[list] gives an approximate object around the mean of the elements of list and with an uncertainty corresponding to their standard deviation.

Around[s] gives an approximate object derived from the number, interval or string specification s.

AroundReplace

AroundReplace[expr,{s1->Around[x1,δ1],s2->Around[x2,δ2],…}] propagates uncertainty in expr by replacing all occurrences of si by Around[xi,δi].

AroundReplace[expr,rules,n] propagates uncertainty in expr using a series expansion to order n.

Array

Array[f,n] generates a list of length n, with elements f[i]. 

Array[f,n,r] generates a list using the index origin r.

Array[f,n,{a,b}] generates a list using n values from a to b.

Array[f,{n1,n2,…}] generates an n1×n2×… array of nested lists, with elements f[i1,i2,…]. 

Array[f,{n1,n2,…},{r1,r2,…}] generates a list using the index origins ri (default 1). 

Array[f,{n1,n2,…},{{a1,b1},{a2,b2},…}] generates a list using ni values from ai to bi.

Array[f,dims,origin,h] uses head h, rather than List, for each level of the array. 

ArrayComponents

ArrayComponents[array] gives an array in which all identical elements of array are replaced by an integer index representing the component in which the element lies.

ArrayComponents[array,level] finds the identical elements at the specified level in array

ArrayComponents[array,level,rules] uses a rule or a list of rules for specifying the labels.

ArrayDepth

ArrayDepth[expr] gives the depth to which expr is a full array, with all the parts at a particular level having the same length.

ArrayFilter

ArrayFilter[f,array,r] applies f to all range-r blocks in the specified array.

ArrayFilter[f,array,{r1,r2,…}] applies f to blocks with ranges r1, r2, … in successive dimensions.

ArrayFilter[f,array,template] applies f over blocks specified by the position of 1s in the array template.

ArrayFlatten

ArrayFlatten[{{m11,m12,…},{m21,m22,…},…}] creates a single flattened matrix from a matrix of matrices mij. 

ArrayFlatten[a,r] flattens out r pairs of levels in the array a.

ArrayPad

ArrayPad[array,m] gives an array with m zeros of padding on every side. 

ArrayPad[array,m,padding] uses the specified padding.

ArrayPad[array,{m,n},…] pads with m elements at the beginning and n elements at the end. 

ArrayPad[array,{{m1,n1},{m2,n2},…},…] pads with mi, ni elements at level i in array. 

ArrayPlot

ArrayPlot[array] generates a plot in which the values in an array are shown in a discrete array of squares. 

ArrayPlot3D

ArrayPlot3D[array] generates a plot in which the values in an array are shown in a discrete array of cubes. 

ArrayQ

ArrayQ[expr] gives True if expr is a full array or a SparseArray object, and gives False otherwise. 

ArrayQ[expr,patt] requires expr to be a full array with a depth that matches the pattern patt. 

ArrayQ[expr,patt,test] requires also that test yield True when applied to each of the array elements in expr. 

ArrayReduce

ArrayReduce[f,array,n] reduces dimension n of array by applying f.

ArrayReduce[f,array,n1;;n2] reduces dimensions n1 through n2.

ArrayReduce[f,array,{n1,n2,…}] reduces dimensions n1, n2, etc.

ArrayReduce[f,array,{{n11,n12,…},{n21,n22,…},…}] applies f to arrays formed by combining all dimensions nij to make each dimension i.

ArrayResample

ArrayResample[array,{n1,n2,…}] resamples array to have dimensions {n1,n2,…}.

ArrayResample[array,dspec] resamples array according to the dimension specification dspec.

ArrayResample[array,dspec,scheme] specifies resampling scheme, either point or bin based. 

ArrayResample[array,dspec,scheme,{{xmin,xmax},…}] resamples only the data in the specified subrange {{xmin,xmax},…}.

ArrayReshape

ArrayReshape[list,dims] arranges the elements of list into a rectangular array with dimensions dims.

ArrayReshape[list,dims,padding] uses the specified padding if list does not contain enough elements.

ArrayRules

ArrayRules[SparseArray[…]] gives the rules {pos1->val1,pos2->val2,…} specifying elements in a sparse array. 

ArrayRules[list] gives rules for SparseArray[list]. 

Arrays

Arrays[{d1,…,dr}] represents the domain of arrays of rank r and dimensions di.

Arrays[{d1,…,dr},dom] represents the domain of arrays of dimensions di, with components in the domain dom.

Arrays[{d1,…,dr},dom,sym] represents the subdomain of arrays with dimensions di and symmetry sym.

Arrow

Arrow[{pt1,pt2}] is a graphics primitive that represents an arrow from pt1 to pt2.

Arrow[{pt1,pt2},s] represents an arrow with its ends set back from pt1 and pt2 by a distance s. 

Arrow[{pt1,pt2},{s1,s2}] sets back by s1 from pt1 and s2 from pt2. 

Arrow[curve,…] represents an arrow following the specified curve.

Arrowheads

Arrowheads[spec] is a graphics directive specifying that arrows that follow should have arrowheads with sizes, positions, and forms specified by spec. 

ASATriangle

ASATriangle[α,c,β] returns a filled triangle with angles α and β and side length c, and c is adjacent to both angles.

AspectRatio

AspectRatio is an option for Graphics and related functions that specifies the ratio of height to width for a plot. 

Assert

Assert[test] represents the assertion that test is True. If assertions have been enabled, test is evaluated when the assertion is encountered. If test is not True, then an assertion failure is generated.

Assert[test,tag] specifies a tag that will be used to identify the assertion if it fails.

AssessmentFunction

AssessmentFunction[key] represents a tool for assessing whether answers are correct according to the key.

AssessmentFunction[key,method] uses the specified answer comparison method.

AssessmentFunction[key,f] uses the function f to compare answers with the key.

AssessmentFunction[key,comp] performs assessment using the custom assessment defined in the Association comp.

AssessmentFunction[obj] represents an assessment function that performs assessment using the CloudObject obj. 

AssessmentFunction[{obj,id}] assesses the specified question within the CloudObject obj.

AssessmentFunction[…][answer] gives an AssessmentResultObject representing the correctness of answer.

AssessmentResultObject

AssessmentResultObject[assoc] represents the results of an assessment.

AssessmentResultObject[{aro1,aro2,…}] represents a collection of many assessments.

AssociateTo

AssociateTo[a,key->val] changes the association a by adding the key-value pair key->val.

AssociateTo[a,{key1->val1,key2->val2,…}] adds all key-value pairs keyi->vali.

Association

Association[key1->val1,key2->val2,…] or <|key1->val1,key2->val2,…|> represents an association between keys and values.

AssociationFormat

AssociationFormat is an option to TextString and related functions that determines how associations are formatted.

AssociationMap

AssociationMap[f,{key1,key2,…}] creates the association <|key1->f[key1],key2->f[key2],…|>.

AssociationMap[f,<|key1->val1,key2->val2,…|>] creates the association <|f[key1->val1],f[key2->val2],…|>.

AssociationMap[f] represents an operator form of AssociationMap that can be applied to an expression.

AssociationQ

AssociationQ[expr] gives True if expr is a valid Association object, and False otherwise.

AssociationThread

AssociationThread[{key1,key2,…}->{val1,val2,…}] gives the association <|key1->val1,key2->val2,…|>.

AssociationThread[{key1,key2,…},{val1,val2,…}] also gives the association <|key1->val1,key2->val2,…|>.

AssumeDeterministic

AssumeDeterministic is an option for functions such as BayesianMinimization that specifies whether or not the function being considered should be assumed to be deterministic.

Assuming

Assuming[assum,expr] evaluates expr with assum appended to $Assumptions, so that assum is included in the default assumptions used by functions such as Refine, Simplify, and Integrate. 

Assumptions

Assumptions is an option for functions such as Simplify, Refine, and Integrate that specifies default assumptions to be made about symbolic quantities. 

AstronomicalData

AstronomicalData["name","property"] gives the value of the specified property of the astronomical object with the specified name.

AstronomicalData["name",{"property",date}] gives the value of a property at a particular date and time.

Asymptotic

Asymptotic[expr,x->x0] gives an asymptotic approximation for expr near x0.

Asymptotic[expr,{x,x0,n}] gives an asymptotic approximation for expr near x0 to order n. 

AsymptoticDSolveValue

AsymptoticDSolveValue[eqn,f,x->x0] computes an asymptotic approximation to the differential equation eqn for f[x] centered at x0.

AsymptoticDSolveValue[{eqn1,eqn2,…},{f1,f2,…},x->x0] computes an asymptotic approximation to a system of differential equations.

AsymptoticDSolveValue[eqn,f,x,ϵ->ϵ0] computes an asymptotic approximation of f[x,ϵ] for the parameter ϵ centered at ϵ0.

AsymptoticDSolveValue[eqn,f,…,{ξ,ξ0,n}] computes the asymptotic approximation to order n. 

AsymptoticEqual

AsymptoticEqual[f,g,x->x*] gives conditions for f(x)≍g(x) or f(x)∈Θ(g(x)) as x->x*.

AsymptoticEqual[f,g,{x1,…,xn}->{x1*,…,xn*}] gives conditions for f(x1,…,xn)≍g(x1,…,xn) or f(x1,…,xn)∈Θ(g(x1,…,xn)) as {x1,…,xn}->{x1*,…,xn*}.

AsymptoticEquivalent

AsymptoticEquivalent[f,g,x->x*] gives conditions for f(x)∼g(x) as x->x*.

AsymptoticEquivalent[f,g,{x1,…,xn}->{x1*,…,xn*}] gives conditions for f(x1,…,xn) ~g(x1,…,xn) as {x1,…,xn}->{x1*,…,xn*}.

AsymptoticExpectation

AsymptoticExpectation[expr,xdist,a->a0] computes an asymptotic approximation for the expectation of expr centered at a0, under the assumption that x follows the probability distribution dist.

AsymptoticExpectation[expr,{x1,x2,…}dist,a->a0] computes an asymptotic approximation for the expectation of expr centered at a0, under the assumption that {x1,x2,…} follows the multivariate distribution dist.

AsymptoticExpectation[expr,vars,{a,a0,n}] computes the asymptotic expectation to order n.

AsymptoticGreater

AsymptoticGreater[f,g,x->x*] gives conditions for f(x)≻g(x) or f(x)∈ω(g(x)) as x->x*.

AsymptoticGreater[f,g,{x1,…,xn}->{x1*,…,xn*}] gives conditions for f(x1,…,xn)≻g(x1,…,xn) or f(x1,…,xn)∈ω(g(x1,…,xn)) as {x1,…,xn}->{x1*,…,xn*}.

AsymptoticGreaterEqual

AsymptoticGreaterEqual[f,g,x->x*] gives conditions for f(x)⪰g(x) or f(x)∈Ω(g(x)) as x->x*.

AsymptoticGreaterEqual[f,g,{x1,…,xn}->{x1*,…,xn*}] gives conditions for f(x1,…,xn)⪰g(x1,…,xn) or f(x1,…,xn)∈Ω(g(x1,…,xn)) as {x1,…,xn}->{x1*,…,xn*}.

AsymptoticLess

AsymptoticLess[f,g,x->x*] gives conditions for f(x)≺g(x) or f(x)∈o(g(x)) as x->x*.

AsymptoticLess[f,g,{x1,…,xn}->{x1*,…,xn*}] gives conditions for f(x1,…,xn)≺g(x1,…,xn) or f(x1,…,xn)∈o(g(x1,…,xn)) as {x1,…,xn}->{x1*,…,xn*}.

AsymptoticLessEqual

AsymptoticLessEqual[f,g,x->x*] gives conditions for f(x)⪯g(x) or f(x)∈O(g(x)) as x->x*.

AsymptoticLessEqual[f,g,{x1,…,xn}->{x1*,…,xn*}] gives conditions for f(x1,…,xn)⪯g(x1,…,xn) or f(x1,…,xn)∈O(g(x1,…,xn)) as {x1,…,xn}->{x1*,…,xn*}.

AsymptoticOutputTracker

AsymptoticOutputTracker[sys,{f1,…},{p1,…}] gives the state feedback control law that causes the outputs of the affine system sys to track the reference signals fi with decay rates pj.

AsymptoticOutputTracker[{sys,{out1,…},{in1,…}},…] specifies outputs outi and control inputs inj to use. 

AsymptoticProbability

AsymptoticProbability[pred,xdist,a->a0] computes an asymptotic approximation for the probability of pred centered at a0, under the assumption that x follows the probability distribution dist.

AsymptoticProbability[pred,{x1,x2,…}dist,a->a0] computes an asymptotic approximation for the probability of pred centered at a0, under the assumption that {x1,x2,…} follows the multivariate distribution dist.

AsymptoticProbability[pred,vars,{a,a0,n}] computes the asymptotic probability to order n.

AsymptoticRSolveValue

AsymptoticRSolveValue[eqn,f,x->∞] computes an asymptotic approximation to the difference equation eqn for f[x] near ∞. 

AsymptoticRSolveValue[{eqn1,eqn2,…},{f1,f2,…},x-> ∞] computes an asymptotic approximation to a system of difference equations.

AsymptoticRSolveValue[eqn,f,x,ϵ->ϵ0] computes an asymptotic approximation of f[x,ϵ] for the parameter ϵ centered at ϵ0.

AsymptoticRSolveValue[eqn,f,…,{ξ,ξ0,n}] computes the asymptotic approximation to order n. 

AsymptoticSolve

AsymptoticSolve[eqn,y->b,x->a] computes asymptotic approximations of solutions y[x] of the equation eqn passing through {a,b}.

AsymptoticSolve[eqn,{y},x->a] computes asymptotic approximations of solutions y[x] of the equation eqn for x near a.

AsymptoticSolve[eqns,{y1,y2,…}->{b1,b2,…},{x1,x2,…}->{a1,a2,…}] computes asymptotic approximations of solutions {y1[x1,x2,…],y2[x1,x2,…],…} of the system of equations eqns.

AsymptoticSolve[eqns,…,{{x1,x2,…},{a1,a2,…},n}] computes the asymptotic approximation to order n. 

AsymptoticSolve[…,Reals] computes only solutions that are real valued for real argument values.

Asynchronous

Asynchronous is an option for WolframAlpha that determines whether to use the asynchronous features of the Wolfram|Alpha API.

AsynchronousTaskObject

AsynchronousTaskObject["name",id,sessionid] is an object that represents asynchronous evaluations from a particular asynchronous task.

AsynchronousTasks

AsynchronousTasks[] returns a list of running asynchronous tasks.

Atom

Atom["sym"] represents an atom with atomic symbol "sym".

Atom["sym",name->value,…] represents an atom with atomic symbol "sym" and specified properties.

AtomCoordinates

AtomCoordinates is an option for Molecule and related functions that specifies the three-dimensional coordinates of the atoms.

AtomDiagramCoordinates

AtomDiagramCoordinates is an option for Molecule and related functions that specifies the two-dimensional coordinates of the atoms.

AtomLabels

AtomLabels is an option for MoleculePlot and MoleculePlot3D that specifies what labels and label positions should be used for atoms.

AtomLabelStyle

AtomLabelStyle is an option for MoleculePlot and MoleculePlot3D that specifies the style to use for atom labels.

AtomQ

AtomQ[expr] yields True if expr is an expression which cannot be divided into subexpressions, and yields False otherwise. 

AttentionLayer

AttentionLayer[] represents a trainable net layer that learns to pay attention to certain portions of its input. 

AttentionLayer[net] specifies a particular net to give scores for portions of the input. 

AttentionLayer[net,opts] includes options for weight normalization, masking and other parameters.

Attributes

Attributes[symbol] gives the list of attributes for a symbol. 

Attributes["symbol"] gives the attributes for the symbol named "symbol" if it exists.

Attributes[{s1,s2,…}] gives a list of the attributes for each of the si.

Audio

Audio[file] represents audio stored in the given file.

Audio[url] represents audio stored in the given URL.

Audio[data] represents audio with samples given by the array data.

AudioAmplify

AudioAmplify[audio,s] multiplies all samples of audio by a factor s. 

AudioAmplify[video,s] amplifies the first audio track in video.

AudioAnnotate

AudioAnnotate[audio,prop] computes the property prop and adds it as an annotation to audio.

AudioAnnotate[audio,name->spec] adds an annotation with the specified name and values spec to audio.

AudioAnnotationLookup

AudioAnnotationLookup[audio] gives all annotations associated to audio.

AudioAnnotationLookup[audio,tags] gives the annotations specified by tags.

AudioAnnotationLookup[audio,tags->selector] gives a selection of annotations using selector.

AudioAnnotationLookup[audio,tags->selector,format] formats each annotation element according to format.

AudioBlockMap

AudioBlockMap[f,audio,dur] applies f to non-overlapping partitions of length dur in audio. 

AudioBlockMap[f,audio,{dur,offset}] applies f to partitions with offset offset in audio. 

AudioBlockMap[f,audio,{dur,offset,wfun}] applies f after applying wfun to partitions in audio. 

AudioChannelAssignment

AudioChannelAssignment is an option for Audio and related functions that specifies a mapping from audio channels to available speakers of the output audio device.

AudioChannelCombine

AudioChannelCombine[{audio1,audio2,…}] creates a multichannel audio object by combining the sequence of channels in audioi.

AudioChannelMix

AudioChannelMix[audio] mixes channels of audio by averaging and returns a center-panned stereo audio object.

AudioChannelMix[audio,desttype] mixes audio channels into the specified desttype.

AudioChannelMix[video,…] mixes audio channels of video.

AudioChannels

AudioChannels[audio] returns the number of channels in the Audio object audio.

AudioChannels[video] returns the number of channels of the first audio track of video.

AudioChannelSeparate

AudioChannelSeparate[audio] gives a list of Audio objects, each of which represents one channel of audio.

AudioChannelSeparate[audio,channel] returns the specified channel from audio.

AudioData

AudioData[audio] gives an array of audio samples.

AudioData[audio,"type"] gives an array of audio samples converted to the specified "type".

AudioDelay

AudioDelay[audio,delay] creates audio by adding repeated decaying echos to audio spaced by the specified delay.

AudioDelay[audio,delay,feedback] uses the specified feedback as the amount of signal to preserve during each repetition.

AudioDelay[audio,delay,feedback,mix] uses mix to control the ratio between original and delayed audio.

AudioDelay[video,…] add delay to the first audio track in video.

AudioDelete

AudioDelete[audio,t] deletes the first t seconds of audio.

AudioDelete[audio,-t] deletes the last t seconds of audio.

AudioDelete[audio,{t1,t2}] deletes from time t1 to time t2, returning the remaining audio as a single Audio object.

AudioDelete[audio,{{t11,t12},…}] deletes multiple time intervals.

AudioDevice

AudioDevice is an option for Audio and related functions that specifies the device to use for playback.

AudioDistance

AudioDistance[audio1,audio2] returns a distance measure between audio1 and audio2.

AudioDistance[video1,video2] returns a distance measure between the audio tracks of video1 and video2.

AudioEncoding

AudioEncoding is an option for Export and other functions that specifies the audio encoding to use when creating an audio or a video file.

AudioFade

AudioFade[audio] returns audio in which the beginning and end of audio are faded.

AudioFade[audio,t] fades the first and last t seconds of audio.

AudioFade[audio,{t1,t2}] fades t1 seconds at the beginning and t2 seconds at the end.

AudioFade[video,…] fades the first audio track in video.

AudioFrequencyShift

AudioFrequencyShift[audio,freq] gives audio by shifting the spectrum of audio by freq.

AudioFrequencyShift[audio,freq,mix] uses mix to control the ratio between the original and shifted audio.

AudioFrequencyShift[video,…] shifts the spectrum of the first audio track in video.

AudioGenerator

AudioGenerator[model] generates one second of audio of a given model.

AudioGenerator[model,t] generates t seconds of audio.

AudioGenerator[model,t,"type"] generates audio samples of the specified "type".

AudioIdentify

AudioIdentify[audio] yields the result of attempting to identify what audio is a recording of.

AudioIdentify[audio,category] restricts the identification to the specified category.

AudioIdentify[audio,category,n] gives a list of up to n possible identifications.

AudioIdentify[audio,category,n,"prop"] gives the specified property for each identification.

AudioInputDevice

AudioInputDevice is an option for AudioCapture that specifies the device to use for audio recording.

AudioInsert

AudioInsert[audio,t->new] inserts the audio signal new at time t.

AudioInsert[audio,{t1,t2,…}->new] inserts the same audio at multiple positions.

AudioInsert[audio,{t1->new1,…}] inserts multiple audio signals at different positions.

AudioInstanceQ

AudioInstanceQ[audio,obj] gives True if audio sounds to be an instance of the object obj, and gives False otherwise.

AudioInstanceQ[audio,obj,cat] assumes that audio is the sound of something in the category cat.

AudioIntervals

AudioIntervals[audio] returns audible intervals of audio.

AudioIntervals[audio,crit] returns intervals of audio for which the criterion crit is satisfied.

AudioIntervals[audio,crit,mindur] returns only intervals larger than the given duration mindur.

AudioIntervals[video,…] returns only intervals from the first audio track in video.

AudioJoin

AudioJoin[audio1,audio2,…] or AudioJoin[{audio1,audio2,…}] concatenates all audioi and returns an audio object.

AudioJoin[{audio1,t1},{audio2,t2},…] inserts ti seconds of silence after each audioi.

AudioLabel

AudioLabel is an option for an Audio object that specifies the label to show on the object.

AudioLength

AudioLength[audio] returns the number of samples in the Audio object audio.

AudioLocalMeasurements

AudioLocalMeasurements[audio,"prop"] computes the property "prop" locally for partitions of audio.

AudioLocalMeasurements[audio,{prop1,prop2,…}] computes several properties "propi".

AudioLocalMeasurements[audio,"prop",format] returns the measurements in the specified output format.

AudioLocalMeasurements[video,…] computes the measurements from the first audio track in video.

AudioLooping

AudioLooping is an option for AudioStream and related functions to specify the playback looping.

AudioLoudness

AudioLoudness[audio] computes the loudness of audio according to the EBU momentary definition.

AudioLoudness[audio,def] computes the loudness according to the definition def.

AudioLoudness[video,…] computes the loudness of the first audio track in video.

AudioMeasurements

AudioMeasurements[audio,"prop"] computes the property "prop" for the entire audio.

AudioMeasurements[audio,{prop1,prop2,…}] computes several properties "propi".

AudioMeasurements[audio,"prop",format] returns the values in the specified output format.

AudioMeasurements[{audio1,audio2,…},…] returns measurements for all audioi.

AudioMeasurements[video,…] returns measurements for the first audio track in video.

AudioNormalize

AudioNormalize[audio] normalizes audio so that the maximum absolute value of its samples is 1.

AudioNormalize[audio,model] normalizes the audio signal based on the specified model.

AudioNormalize[video] normalizes the first audio track in video.

AudioOutputDevice

AudioOutputDevice is an option for Audio and related functions that specifies the device to use for playback.

AudioOverlay

AudioOverlay[{audio1,audio2,…}] returns an audio object by overlaying all audioi.

AudioPad

AudioPad[audio,t] adds t seconds of silence to the end of audio.

AudioPad[audio,{t1,t2}] adds t1 seconds of silence to the beginning and t2 seconds to the end of audio.

AudioPad[audio,tspec,padding] pads using the value or method specified by padding.

AudioPan

AudioPan[audio] returns a center-panned stereo audio object from a mono audio. 

AudioPan[audio,pan] returns a stereo audio object after panning left and right channels using the specified pan.

AudioPan[video,…] pans the first audio track in video.

AudioPartition

AudioPartition[audio,dur] partitions an audio object into non-overlapping segments of duration dur.

AudioPartition[audio,dur,offset] generates segments with specified offset.

AudioPause

AudioPause[] pauses the playback of all AudioStream objects.

AudioPause[astream] pauses the playback of the AudioStream object astream.

AudioPause[audio] pauses the playback for all streams originated by audio.

AudioPitchShift

AudioPitchShift[audio,r] applies pitch shifting to audio by the ratio r, shifting every frequency f to r f.

AudioPitchShift[video,r] applies pitch shifting to the first audio track in video.

AudioPlay

AudioPlay[audio] returns a new AudioStream object from audio and starts the playback.

AudioPlay[astream] starts playing an AudioStream object astream.

AudioPlot

AudioPlot[audio] plots the waveform of audio.

AudioPlot[{audio1,audio2,…}] plots waveforms of all audioi.

AudioPlot[video] plots the waveform of the first audio track in video.

AudioQ

AudioQ[audio] yields True if audio has the form of a valid Audio object, and False otherwise.

AudioRecord

AudioRecord[] returns a new AudioStream object and starts to record from the default input audio device.

AudioRecord[inputdev] records from the input audio device inputdev.

AudioRecord[astream] starts recording an AudioStream object astream that is connected to an input device.

AudioReplace

AudioReplace[audio,{t1,t2}->new] replaces the audio signal between t1 and t2 with the new signal new.

AudioReplace[audio,{{t11,t12},…}->new] replaces multiple intervals with the same audio new.

AudioReplace[audio,{{t11,t12}->new1,…}] replaces multiple intervals.

AudioReplace[audio,{t1,t2}->new,fitting] uses the specified fitting method.

AudioResample

AudioResample[audio,sr] resamples audio to have the sample rate of sr.

AudioResample[video,sr] resamples the first audio track in video to have the sample rate of sr.

AudioReverb

AudioReverb[audio] adds reverberation to audio.

AudioReverb[audio,model] adds reverberation following the room model.

AudioReverb[audio,model,mix] controls the mix ratio between original and reverberated audio.

AudioReverb[video,…] adds reverberation to the first audio track in video.

AudioReverse

AudioReverse[audio] reverses audio so that the signal is played backward.

AudioReverse[video] reverses the first audio track in video.

AudioSampleRate

AudioSampleRate[audio] returns the sample rate of the Audio object audio.

AudioSampleRate[video] returns the sample rate of the first audio track of video.

AudioSpectralMap

AudioSpectralMap[f,audio] transforms audio by applying the function f to its short-time Fourier transform.

AudioSpectralMap[f,{audio1,…}] applies the function f to the list of short-time Fourier transforms of all audioi.

AudioSpectralMap[f,video] transforms the first audio track in video.

AudioSpectralTransformation

AudioSpectralTransformation[f,audio] returns a modified version of audio by applying a time-frequency transformation f to its short-time Fourier transform.

AudioSpectralTransformation[f,video] transforms the first audio track in video.

AudioSplit

AudioSplit[audio,t] splits audio at time t.

AudioSplit[audio,{t1,t2,…}] splits audio at times ti.

AudioStop

AudioStop[] stops the playback of all AudioStream objects.

AudioStop[astream] stops the playback of the AudioStream object astream.

AudioStop[audio] stops the playback for all streams originated by audio.

AudioStream

AudioStream[source] creates a new AudioStream object from source.

AudioStream[id] is an object that represents a unique audio stream.

AudioStreams

AudioStreams[] returns all existing streams.

AudioStreams[audio] returns all existing streams that originated from audio.

AudioStreams[audio,"prop"] returns "prop" for all streams that originated from audio.

AudioTimeStretch

AudioTimeStretch[audio,r] applies time stretching to audio by the specified factor r.

AudioTimeStretch[video,r] applies time stretching to the first audio track in video.

AudioTrackApply

AudioTrackApply[f,video] applies the function f to the first audio track of the Video object video.

AudioTrackSelection

AudioTrackSelection is an option that specifies the audio tracks of interest.

AudioTrim

AudioTrim[audio] trims silence from the beginning and end of audio.

AudioTrim[audio,t] returns the first t seconds of audio.

AudioTrim[audio,-t] returns the last t seconds of audio.

AudioTrim[audio,{t1,t2}] returns audio starting at time t1 and ending at time t2 of audio.

AudioTrim[audio,{{t11,t12},…}] returns a list of audio for all given intervals {ti1,ti2}.

AudioType

AudioType[audio] returns the data type used to represent samples in the Audio object audio.

AugmentedPolyhedron

AugmentedPolyhedron[poly] gives the augmented polyhedron poly by replacing each face by a pyramid. 

AugmentedPolyhedron[poly,h] gives the augmented polyhedron with a pyramid of height h.

AugmentedSymmetricPolynomial

AugmentedSymmetricPolynomial[{r1,r2,…}] represents a formal augmented symmetric polynomial with exponents r1, r2, ….

AugmentedSymmetricPolynomial[{{r11,…,r1n},{r21,…,r2n},…}] represents a multivariate formal augmented symmetric polynomial with exponent vectors {r11, …, r1n}, {r21, …, r2n}, ….

AugmentedSymmetricPolynomial[rspec,data] gives the augmented symmetric polynomial in data.

Autocomplete

Autocomplete[{string1,string2,…},"string"] gives a list of the stringi that can complete string.

Autocomplete[<|s1->w1,s2->w2,…|>,"string"] puts the completions in order of decreasing weights wi.

Autocomplete[{assoc1,assoc2,…},"string"] uses completions specified by the associations associ.

Autocomplete[comps,"string",n] gives the first at most n completions.

Autocomplete[comps] gives an AutocompletionFunction[…] that can be applied to a string.

AutocompletionFunction

AutocompletionFunction[…] represents a function to be applied to a string to generate possible completions. 

AutocorrelationTest

AutocorrelationTest[data] tests whether the data is autocorrelated.

AutocorrelationTest[data,k] tests whether the data is autocorrelated up to lag k.

AutocorrelationTest[data,k,"property"] returns the value of "property" for a given model.

AutoIndent

AutoIndent is an option for Style and Cell that specifies what automatic indentation should be done at the beginning of a new line after an explicit return character has been entered. 

AutoItalicWords

AutoItalicWords is an option for Cell that gives a list of words that should automatically be put in italics when they are entered. 

AutoloadPath

AutoloadPath is a global option that specifies from which directories packages are automatically loaded when the Wolfram System is started.

Automatic

Automatic represents an option or other value that is to be chosen automatically by a built‐in function. 

Axes

Axes is an option for graphics functions that specifies whether axes should be drawn. 

AxesEdge

AxesEdge is an option for three-dimensional graphics functions that specifies on which edges of the bounding box axes should be drawn. 

AxesLabel

AxesLabel is an option for graphics functions that specifies labels for axes. 

AxesOrigin

AxesOrigin is an option for graphics functions that specifies where any axes drawn should cross. 

AxesStyle

AxesStyle is an option for graphics functions that specifies how axes should be rendered. 

AxiomaticTheory

AxiomaticTheory["theory"] gives an axiomatic representation of the specified axiomatic theory.

AxiomaticTheory[{"theory",<|op1->s1,op2->s2,…|>}] uses si to represent the operator opi in the theory.

AxiomaticTheory[theory,"property"] gives the specified property of an axiomatic theory.

Axis

Axis is a symbol that represents the axis for purposes of alignment and positioning. 

AxisLabel

AxisLabel is an option for AxisObject that specifies a label for the axis.

AxisObject

AxisObject[path] is a Graphics primitive that represents an axis with a quantitative scale along the path path.

AxisObject[path,scale] uses the scale specified by scale.

AxisStyle

AxisStyle is an option for AxisObject that specifies how to style the path of an axis.

BabyMonsterGroupB

BabyMonsterGroupB[] represents the sporadic simple baby monster group B.

Back

Back is a symbol that represents the back of a graphic for purposes of placement and alignment.

Background

Background is an option that specifies what background color to use. 

Backslash

Backslash[x,y,…] displays as x∖y∖….

Backward

Backward is a symbol that represents the backward direction for purposes of motion and animation.

Ball

Ball[p] represents the unit ball centered at the point p.

Ball[p,r] represents the ball of radius r centered at the point p.

Ball[{p1,p2,…},r] represents a collection of balls of radius r.

Band

Band[{i,j}] represents the sequence of positions on the diagonal band that starts with {i,j} in a sparse array.

Band[{imin,jmin,…},{imax,jmax,…}] represents the positions between {imin,jmin,…} and {imax,jmax,…}.

Band[{imin,jmin,…},{imax,jmax,…},{di,dj,…}] represents positions starting with {imin,jmin,…} and then moving with step {di,dj,…}.

BandpassFilter

BandpassFilter[data,{ω1,ω2}] applies a bandpass filter with cutoff frequencies ω1 and ω2 to an array of data.

BandpassFilter[data,{{ω,q}}] uses center frequency ω and quality factor q.

BandpassFilter[data,spec,n] uses a filter kernel of length n.

BandpassFilter[data,spec,n,wfun] applies a smoothing window wfun to the filter kernel.

BandstopFilter

BandstopFilter[data,{ω1,ω2}] applies a bandstop filter with cutoff frequencies ω1 and ω2 to an array of data.

BandstopFilter[data,{{ω,q}}] uses center frequency ω and quality factor q. 

BandstopFilter[data,spec,n] uses a filter kernel of length n.

BandstopFilter[data,spec,n,wfun] applies a smoothing window wfun to the filter kernel.

BarabasiAlbertGraphDistribution

BarabasiAlbertGraphDistribution[n,k] represents a Barabasi–Albert graph distribution for n-vertex graphs where a new vertex with k edges is added at each step.

BarChart

BarChart[{y1,y2,…,yn}] makes a bar chart with bar lengths y1,  y2, ….

BarChart[{…,wi[yi,…],…,wj[yj,…],…}] makes a bar chart with bar features defined by the symbolic wrappers wk.

BarChart[{data1,data2,…}] makes a bar chart from multiple datasets datai. 

BarChart3D

BarChart3D[{y1,y2,…}] makes a 3D bar chart with bar lengths y1, y2, … .

BarChart3D[{…,wi[yi,…],…,wj[yj,…],…}] makes a 3D bar chart with bar features defined by the symbolic wrappers wk.

BarChart3D[{data1,data2,…}] makes a 3D bar chart from multiple datasets datai. 

BarcodeImage

BarcodeImage["string"] generates a barcode image of "string" in the "QR" format.

BarcodeImage["string",format] generates a barcode image of "string" in the specified format.

BarcodeImage["string",format,size] attempts to generate a barcode image of the specified size.

BarcodeRecognize

BarcodeRecognize[image] recognizes a barcode in image and returns it as a string.

BarcodeRecognize[image,"prop"] returns the specified property of the barcode.

BarcodeRecognize[image,"prop",format] recognizes barcodes of the specified format only.

BarcodeRecognize[video,…] recognizes barcodes in frames of video.

BaringhausHenzeTest

BaringhausHenzeTest[data] tests whether data follows a MultinormalDistribution using the Baringhaus–Henze test.

BaringhausHenzeTest[data,MultinormalDistribution[μ,Σ]] tests whether data follows the distribution with mean vector μ and covariance matrix Σ.

BaringhausHenzeTest[data,"property"] returns the value of "property". 

BarLegend

BarLegend[cf] generates a legend that identifies colors from the color function cf with an automatic range of values.

BarLegend[{cf,{min,max}}] generates a legend that identifies colors from the color function cf with the range of values between min and max.

BarLegend[cf,contours] generates a legend that identifies color ranges from the color function cf based on the set of contours contours.

BarlowProschanImportance

BarlowProschanImportance[rdist] gives the Barlow–Proschan importances for all components in the ReliabilityDistribution rdist. 

BarlowProschanImportance[fdist] gives the Barlow–Proschan importances for all components in the FailureDistribution fdist.

BarnesG

BarnesG[z] gives the Barnes G-function G(z).

BarOrigin

BarOrigin is an option to BarChart and related functions that specifies the origin placement for bars. 

BarSpacing

BarSpacing is an option to BarChart and related functions that controls the spacing between bars and groups of bars.

BartlettHannWindow

BartlettHannWindow[x] represents a Bartlett–Hann window function of x.

BartlettWindow

BartlettWindow[x] represents a Bartlett window function of x.

BaseDecode

BaseDecode["string"] decodes the Base64 data contained in a string and returns the result as a byte array.

BaseDecode["string","encoding"] decodes using the string using the specified encoding.

BaseEncode

BaseEncode[ba] encodes the byte array ba as a Base64 string.

BaseEncode[ba,"encoding"] encodes using the specified encoding.

BaseForm

BaseForm[expr,n] prints with the numbers in expr given in base n. 

Baseline

Baseline is a symbol that represents the baseline for purposes of alignment and positioning. 

BaselinePosition

BaselinePosition is an option that specifies where the baseline of an object is considered to be for purposes of alignment with surrounding text or other expressions. 

BasicRecurrentLayer

BasicRecurrentLayer[n] represents a trainable recurrent layer that takes a sequence of vectors and produces a sequence of vectors each of size n.

BasicRecurrentLayer[n,opts] includes options for initial weights and other parameters. 

BatchNormalizationLayer

BatchNormalizationLayer[] represents a trainable net layer that normalizes its input data by learning the data mean and variance.

BatchSize

BatchSize is an option for NetTrain and related functions that specifies the size of a batch of examples to process together.

BatesDistribution

BatesDistribution[n] represents the distribution of a mean of n random variables uniformly distributed from 0 to 1.

BatesDistribution[n,{min,max}] represents the distribution of a mean of n random variables uniformly distributed from min to max.

BattleLemarieWavelet

BattleLemarieWavelet[] represents the Battle–Lemarié wavelet of order 3.

BattleLemarieWavelet[n] represents the Battle–Lemarié wavelet of order n evaluated on equally spaced interval {-10,10}.

BattleLemarieWavelet[n,lim] represents the Battle–Lemarié wavelet of order n evaluated on equally spaced interval {-lim,lim}. 

BayesianMaximization

BayesianMaximization[f,{conf1,conf2,…}] gives an object representing the result of Bayesian maximization over the function f over the configurations confi.

BayesianMaximization[f,reg] maximizes over the region represented by the region specification reg.

BayesianMaximization[f,sampler] maximizes over configurations obtained by applying the function sampler.

BayesianMaximization[f,{conf1,conf2,…}->nsampler] applies the function nsampler to successively generate configurations starting from the confi.

BayesianMaximizationObject

BayesianMaximizationObject[…] represents the result of a Bayesian maximization process.

BayesianMinimization

BayesianMinimization[f,{conf1,conf2,…}] gives an object representing the result of Bayesian minimization of the function f over the configurations confi. 

BayesianMinimization[f,reg] minimizes over the region represented by the region specification reg.

BayesianMinimization[f,sampler] minimizes over configurations obtained by applying the function sampler. 

BayesianMinimization[f,{conf1,conf2,…}->nsampler] applies the function nsampler to successively generate configurations starting from the confi. 

BayesianMinimizationObject

BayesianMinimizationObject[…] represents the result of a Bayesian minimization process. 

Because

Because[x,y] displays as x∵y.

BeckmannDistribution

BeckmannDistribution[μ1,μ2,σ1,σ2] represents the Beckmann distribution with means μ1 and μ2 and standard deviations σ1 and σ2.

BeckmannDistribution[μ1,μ2,σ1,σ2,ρ] represents the Beckmann distribution with means μ1 and μ2, standard deviations σ1 and σ2, and correlation ρ.

Beep

Beep[] generates an audible beep when evaluated. 

Beep["message"] beeps and populates the Why the Beep dialog with message.

Before

Before is a symbol that represents the region before an object for purposes of placement.

Begin

Begin["context`"] resets the current context. 

BeginDialogPacket

BeginDialogPacket[integer] is a WSTP packet that indicates the start of the Dialog subsession referenced by integer.

BellB

BellB[n] gives the Bell number Bn. 

BellB[n,x] gives the Bell polynomial Bn(x). 

BellY

BellY[n,k,{x1,…,xn-k+1}] gives the partial Bell polynomial Yn,k(x1,…,xn-k+1).

BellY[n,k,m] gives the generalized partial Bell polynomial of a matrix m.

BellY[m] gives the generalized Bell polynomial of a matrix m.

Below

Below is a symbol that represents the region below an object for purposes of placement.

BenfordDistribution

BenfordDistribution[b] represents a Benford distribution with base parameter b.

BeniniDistribution

BeniniDistribution[α,β,σ] represents a Benini distribution with shape parameters α and β and scale parameter σ.

BenktanderGibratDistribution

BenktanderGibratDistribution[a,b] represents a Benktander distribution of type I with parameters a and b.

BenktanderWeibullDistribution

BenktanderWeibullDistribution[a,b] represents a Benktander distribution of type II with parameters a and b.

BernoulliB

BernoulliB[n] gives the Bernoulli number Bn. 

BernoulliB[n,x] gives the Bernoulli polynomial Bn(x). 

BernoulliDistribution

BernoulliDistribution[p] represents a Bernoulli distribution with probability parameter p.

BernoulliGraphDistribution

BernoulliGraphDistribution[n,p] represents a Bernoulli graph distribution for n-vertex graphs with edge probability p.

BernoulliProcess

BernoulliProcess[p] represents a Bernoulli process with event probability p.

BernsteinBasis

BernsteinBasis[d,n,x] represents the nth Bernstein basis function of degree d at x.

BesagL

BesagL[pdata,r] estimates Besag's L function L(r) for point data pdata at radius r.

BesagL[pproc,r] computes L(r) for the point process pproc.

BesagL[bdata,r] computes L(r) for binned data bdata. 

BesagL[pspec] generates the function L that can be applied repeatedly to different radii r.

BesselFilterModel

BesselFilterModel[n] designs a lowpass Bessel filter of order n and cutoff frequency 1.

BesselFilterModel[{n,ωc}] uses the cutoff frequency ωc.

BesselFilterModel[{n,ωc},var] expresses the model in terms of the variable var.

BesselI

BesselI[n,z] gives the modified Bessel function of the first kind In(z). 

BesselJ

BesselJ[n,z] gives the Bessel function of the first kind Jn(z). 

BesselJZero

BesselJZero[n,k] represents the kth zero of the Bessel function Jn(x).

BesselJZero[n,k,x0] represents the kth zero greater than x0.

BesselK

BesselK[n,z] gives the modified Bessel function of the second kind Kn(z). 

BesselY

BesselY[n,z] gives the Bessel function of the second kind Yn(z). 

BesselYZero

BesselYZero[n,k] represents the kth zero of the Bessel function of the second kind Yn(x).

BesselYZero[n,k,x0] represents the kth zero greater than x0.

Beta

Beta[a,b] gives the Euler beta function Β(a,b). 

Beta[z,a,b] gives the incomplete beta function Βz(a,b). 

BetaBinomialDistribution

BetaBinomialDistribution[α,β,n] represents a beta binomial mixture distribution with beta distribution parameters α and β, and n binomial trials.

BetaDistribution

BetaDistribution[α,β] represents a continuous beta distribution with shape parameters α and β.

BetaNegativeBinomialDistribution

BetaNegativeBinomialDistribution[α,β,n] represents a beta negative binomial mixture distribution with beta distribution parameters α and β and n successful trials.

BetaPrimeDistribution

BetaPrimeDistribution[p,q] represents a beta prime distribution with shape parameters p and q. 

BetaPrimeDistribution[p,q,β] represents a generalized beta prime distribution with scale parameter β.

BetaPrimeDistribution[p,q,α,β] represents a generalized beta distribution of the second kind with shape parameter α.

BetaRegularized

BetaRegularized[z,a,b] gives the regularized incomplete beta function Iz(a,b). 

Between

Between[x,{min,max}] is equivalent to min≤x≤max.

Between[x,{{min1,max1},{min2,max2},…}] is equivalent to min1≤x≤max1||min2≤x≤max2||….

Between[range] is an operator form that yields Between[x,range] when applied to an expression x.

BetweennessCentrality

BetweennessCentrality[g] gives a list of betweenness centralities for the vertices in the graph g.

BetweennessCentrality[{v->w,…}] uses rules v->w to specify the graph g. 

BeveledPolyhedron

BeveledPolyhedron[poly] gives the beveled polyhedron of poly, by beveling each edge. 

BeveledPolyhedron[poly,l] bevels the polyhedron poly by a length ratio l at its edges.

BezierCurve

BezierCurve[{pt1,pt2,…}] is a graphics primitive that represents a Bézier curve with control points pti.

BezierFunction

BezierFunction[{pt1,pt2,…}] represents a Bézier function for a curve defined by the control points pti.

BezierFunction[array] represents a Bézier function for a surface or high-dimensional manifold. 

BilateralFilter

BilateralFilter[data,σ,μ] applies a bilateral filter of spatial spread σ and pixel value spread μ to data.

BilateralLaplaceTransform

BilateralLaplaceTransform[expr,t,s] gives the bilateral Laplace transform of expr. 

BilateralLaplaceTransform[expr,{t1,t2,…,tn},{s1,s2,…,sn}] gives the multidimensional bilateral Laplace transform of expr. 

BilateralZTransform

BilateralZTransform[expr,n,z] gives the bilateral Z transform of expr.

BilateralZTransform[expr,{n1,…,nk},{z1,…,zk}] gives the multidimensional bilateral Z transform of expr.

Binarize

Binarize[image] creates a binary image from image by replacing all values above a globally determined threshold with 1 and others with 0.

Binarize[image,t] creates a binary image by replacing all values above t with 1 and others with 0.

Binarize[image,{t1,t2}] creates a binary image by replacing all values in the range t1 through t2 with 1 and others with 0.

Binarize[image,f] creates a binary image by replacing all channel value lists for which f[v] yields True with 1 and others with 0.

BinaryDeserialize

BinaryDeserialize[ByteArray[…]] recovers an expression from a binary representation generated by BinarySerialize.

BinaryDeserialize[ByteArray[…],h] wraps h around the expression produced before returning it.

BinaryDistance

BinaryDistance[u,v] gives the binary distance between vectors u and v, equal to 0 if they are identical and 1 otherwise.

BinaryFormat

BinaryFormat is an option for OpenRead and related functions that specifies that a stream should be opened in binary format, so that no textual interpretation of newlines or other data is done.

BinaryImageQ

BinaryImageQ[image] yields True if image has the form of a binary Image or Image3D object, and False otherwise.

BinaryRead

BinaryRead[stream] reads one byte of raw binary data from an input stream, and returns an integer from 0 to 255. 

BinaryRead[stream,type] reads an object of the specified type. 

BinaryRead[stream,{type1,type2,…}] reads a sequence of objects of the specified types.

BinaryReadList

BinaryReadList["file"] reads all remaining bytes from a file, and returns them as a list of integers from 0 to 255. 

BinaryReadList["file",type] reads objects of the specified type from a file, until the end of the file is reached. The list of objects read is returned. 

BinaryReadList["file",{type1,type2,…}] reads objects with a sequence of types, until the end of the file is reached. 

BinaryReadList["file",types,n] reads only the first n objects of the specified types. 

BinarySerialize

BinarySerialize[expr] gives a binary representation of any expression expr as a ByteArray object.

BinaryWrite

BinaryWrite[channel,b] writes a byte of data, specified as an integer from 0 to 255. 

BinaryWrite[channel,{b1,b2,…}] writes a sequence of bytes. 

BinaryWrite[channel,"string"] writes the raw sequence of characters in a string. 

BinaryWrite[channel,ByteArray[…]] writes the contents of a ByteArray object.

BinaryWrite[channel,x,type] writes an object of the specified type. 

BinaryWrite[channel,{x1,x2,…},type] writes a sequence of objects of the specified type. 

BinaryWrite[channel,{x1,x2,…},{type1,type2,…}] writes a sequence of objects with a sequence of types. 

BinCounts

BinCounts[data] counts the number of elements of data whose values lie in successive integer bins.

BinCounts[data,binspec] counts the number of elements of data whose values lie in successive bins specified by binspec.

BinLists

BinLists[data] gives lists of the elements of data whose values lie in successive integer bins.

BinLists[data,binspec] gives lists of the elements of data whose values lie in successive bins specified by binspec.

BinLists[data->inds,…] gives the lists of the labels inds specified by the binning of data.

BinnedVariogramList

BinnedVariogramList[{loc1->val1,loc2->val2,…}] computes a variogram using binned values. 

BinnedVariogramList[{loc1,loc2,…}->{val1,val2,…}] generates the same result.

BinnedVariogramList[…,spec] allows binning spec to be specified as given in HistogramList. 

Binomial

Binomial[n,m] gives the binomial coefficient (�).

BinomialDistribution

BinomialDistribution[n,p] represents a binomial distribution with n trials and success probability p.

BinomialPointProcess

BinomialPointProcess[n,reg] represents a binomial point process with n points in the region reg.

BinomialProcess

BinomialProcess[p] represents a binomial process with event probability p.

BioSequenceModify

BioSequenceModify[seq,"mod"] gives the result of applying the modification "mod" to the sequence seq.

BioSequenceModify[seq,{"mod",params}] specifies the parameters params for "mod".

BioSequenceModify[modspec] represents an operator form of BioSequenceModify that can be applied to a biomolecular sequence.

BipartiteGraphQ

BipartiteGraphQ[g] yields True if the graph g is a bipartite graph and False otherwise.

BiquadraticFilterModel

BiquadraticFilterModel[{ω,q}] creates a lowpass biquadratic filter using the characteristic frequency ω and the quality factor q.

BiquadraticFilterModel[{"type",spec}] creates a filter of a given {"type",spec}.

BiquadraticFilterModel[{"type",spec},var] expresses the model in terms of the variable var.

BirnbaumImportance

BirnbaumImportance[rdist,t] gives the Birnbaum importances for all components in the ReliabilityDistribution rdist at time t.

BirnbaumImportance[fdist,t] gives the Birnbaum importances for all components in the FailureDistribution fdist at time t.

BirnbaumSaundersDistribution

BirnbaumSaundersDistribution[α,λ] represents the Birnbaum–Saunders distribution with shape parameter α and scale parameter λ.

BitAnd

BitAnd[n1,n2,…] gives the bitwise AND of the integers ni. 

BitClear

BitClear[n,k] sets to 0 the bit corresponding to the coefficient of 2k in the integer n. 

BitGet

BitGet[n,k] gets the bit corresponding to the coefficient of 2k in the integer n. 

BitLength

BitLength[n] gives the number of binary bits necessary to represent the integer n. 

BitNot

BitNot[n] gives the bitwise NOT of the integer n. 

BitOr

BitOr[n1,n2,…] gives the bitwise OR of the integers ni. 

BitRate

BitRate is an option that specifies an approximate number of bits per second when creating video and audio files.

BitSet

BitSet[n,k] sets to 1 the bit corresponding to the coefficient of 2k in the integer n. 

BitShiftLeft

BitShiftLeft[n,k] shifts the binary bits in the integer n to the left by k places, padding with zeros on the right.

BitShiftLeft[n] shifts one bit to the left.

BitShiftRight

BitShiftRight[n,k] shifts the binary bits in the integer n to the right by k places, dropping bits that are shifted past the unit's position on the right. 

BitShiftRight[n] shifts one bit to the right.

BitXor

BitXor[n1,n2,…] gives the bitwise XOR of the integers ni. 

BiweightLocation

BiweightLocation[list] gives the value of the biweight location estimator of the elements in list.

BiweightLocation[list,c] gives the value of the biweight location estimator with scaling parameter c.

BiweightMidvariance

BiweightMidvariance[list] gives the value of the biweight midvariance of the elements in list.

BiweightMidvariance[list,c] gives the value of the biweight midvariance with scaling parameter c.

Black

Black represents the color black in graphics or style specifications. 

BlackmanHarrisWindow

BlackmanHarrisWindow[x] represents a Blackman–Harris window function of x.

BlackmanNuttallWindow

BlackmanNuttallWindow[x] represents a Blackman–Nuttall window function of x.

BlackmanWindow

BlackmanWindow[x] represents a Blackman window function of x.

Blank

_ or Blank[] is a pattern object that can stand for any Wolfram Language expression. 

_h or Blank[h] can stand for any expression with head h. 

BlankNullSequence

___ (three _ characters) or BlankNullSequence[] is a pattern object that can stand for any sequence of zero or more Wolfram Language expressions. 

___h or BlankNullSequence[h] can stand for any sequence of expressions, all of which have head h. 

BlankSequence

__ (two _ characters) or BlankSequence[] is a pattern object that can stand for any sequence of one or more Wolfram Language expressions. 

__h or BlankSequence[h] can stand for any sequence of one or more expressions, all of which have head h. 

Blend

Blend[{col1,col2},x] gives a color obtained by blending a fraction 1-x of color col1 and x of color col2.

Blend[{col1,col2,col3,…},x] linearly interpolates between colors coli as x varies from 0 to 1.

Blend[{{x1,col1},{x2,col2},…},x] interpolates to give coli when x=xi.

Blend[{col1,col2,…},{u1,u2,…}] blends all the coli, using fraction ui of color coli. 

Blend[{image1,image2,…},…] blends pixel values of 2D or 3D images imagei.

Block

Block[{x,y,…},expr] specifies that expr is to be evaluated with local values for the symbols x, y, …. 

Block[{x=x0,…},expr] defines initial local values for x, …. 

BlockMap

BlockMap[f,list,n] applies f to non-overlapping sublists of length n in list. 

BlockMap[f,list,n,d] applies f to sublists with offset d in list. 

BlockMap[f,list,{n1,n2,…},…] applies f to blocks of size n1×n2×….

BlockRandom

BlockRandom[expr] evaluates expr with all pseudorandom generators localized, so that uses of SeedRandom, RandomInteger, and related functions within the evaluation of expr do not affect subsequent pseudorandom sequences.

BlomqvistBetaTest

BlomqvistBetaTest[v1,v2] tests whether the vectors v1 and v2 are independent.

BlomqvistBetaTest[m1,m2] tests whether the matrices m1 and m2 are independent.

BlomqvistBetaTest[…,"property"] returns the value of "property".

Blue

Blue represents the color blue in graphics or style specifications. 

Blur

Blur[image] gives a blurred version of image.

Blur[image,r] gives a version of image blurred over pixel radius r.

BodePlot

BodePlot[lsys] generates a Bode plot of a linear time-invariant system lsys.

BodePlot[lsys,{ωmin,ωmax}] plots for the frequency range ωmin to ωmax.

BodePlot[expr,{ω,ωmin,ωmax}] plots expr using the variable ω.

BohmanWindow

BohmanWindow[x] represents a Bohman window function of x.

Bold

Bold represents a bold font weight.

Bond

Bond[{idi,idj},type] represents a chemical bond between atoms with indices idi and idj of the specified type.

BondLabels

BondLabels is an option for MoleculePlot and MoleculePlot3D that specifies what labels and label positions should be used for bonds.

BondLabelStyle

BondLabelStyle is an option for MoleculePlot and MoleculePlot3D that specifies the style to use for bond labels.

Bookmarks

Bookmarks is an option for Manipulate and related functions that gives a list of bookmark settings.

Boole

Boole[expr] yields 1 if expr is True and 0 if it is False. 

BooleanConvert

BooleanConvert[expr] converts the Boolean expression expr to disjunctive normal form.

BooleanConvert[expr,form] converts the Boolean expression expr to the specified form.

BooleanConvert[expr,form,cond] finds an expression in the specified form that is equivalent to expr when cond is true.

BooleanCountingFunction

BooleanCountingFunction[kmax,n] represents a Boolean function of n variables that gives True if at most kmax variables are True.

BooleanCountingFunction[{k},n] represents a function of n variables that gives True if exactly k variables are True.

BooleanCountingFunction[{kmin,kmax},n] represents a function that gives True if between kmin and kmax variables are True.

BooleanCountingFunction[{{k1,k2,…}},n] represents a function that gives True if exactly ki variables are True.

BooleanCountingFunction[spec,{a1,a2,…}] gives the Boolean expression in variables ai corresponding to the Boolean counting function specified by spec.

BooleanCountingFunction[spec,{a1,a2,…},form] gives the Boolean expression in the form specified by form.

BooleanFunction

BooleanFunction[k,n] represents the kth Boolean function in n variables.

BooleanFunction[values] represents the Boolean function corresponding to the specified vector of truth values.

BooleanFunction[{{i11,i12,…}->o1,…}] represents the Boolean function defined by the specified mapping from inputs to outputs.

BooleanFunction[spec,{a1,a2,…}] gives the Boolean expression in variables ai corresponding to the Boolean function specified by spec.

BooleanFunction[spec,{a1,a2,…},form] gives the Boolean expression in the form specified by form.

BooleanGraph

BooleanGraph[bfunc,g1,…,gn] gives the Boolean graph defined by the Boolean function bfunc on the graphs g1, …, gn.

BooleanMaxterms

BooleanMaxterms[k,n] represents the kth maxterm in n variables.

BooleanMaxterms[{k1,k2,…},n] represents the conjunction of the maxterms ki.

BooleanMaxterms[{{u1,…,un},{v1,…},…}] represents the conjunction of maxterms given by the exponent vectors ui, vi, ….

BooleanMaxterms[spec,{a1,a2,…}] gives the Boolean expression in variables ai corresponding to the maxterms function specified by spec.

BooleanMaxterms[spec,{a,a2,…},form] gives the Boolean expression in the form specified by form.

BooleanMinimize

BooleanMinimize[expr] finds a minimal-length disjunctive normal form representation of expr.

BooleanMinimize[expr,form] finds a minimal-length representation for expr in the specified form.

BooleanMinimize[expr,form,cond] finds a minimal-length expression in the specified form that is equivalent to expr when cond is true.

BooleanMinterms

BooleanMinterms[k,n] represents the kth minterm in n variables.

BooleanMinterms[{k1,k2,…},n] represents the disjunction of the minterms ki.

BooleanMinterms[{{u1,…,un},{v1,…},…}] represents the disjunction of minterms given by the exponent vectors ui, vi, ….

BooleanMinterms[spec,{a1,a2,…}] gives the Boolean expression in variables ai corresponding to the minterms function specified by spec.

BooleanMinterms[spec,{a,a2,…},form] gives the Boolean expression in the form specified by form.

BooleanQ

BooleanQ[expr] returns True if expr is either True or False.

BooleanRegion

BooleanRegion[bfunc,{reg1,reg2,…}] represents the Boolean combination bfunc of regions reg1, reg2, ….

Booleans

Booleans represents the domain of Booleans, as in x∈Booleans. 

BooleanStrings

BooleanStrings is an option to TextString and related functions that determines what strings correspond to the Wolfram Language symbols True and False.

BooleanTable

BooleanTable[bf] gives a list of truth values for all possible combinations of variable values supplied to the Boolean function bf.

BooleanTable[expr,{a1,a2,…}] gives a list of the truth values of the Boolean expression expr for all possible combinations of values of the ai.

BooleanTable[expr,{a1,a2,…},{b1,…},…] gives a nested table of truth values of expr with the outermost level giving possible combinations of the ai.

BooleanVariables

BooleanVariables[expr] gives a list of the Boolean variables in the Boolean expression expr.

BooleanVariables[bf] gives the number of Boolean variables in the BooleanFunction object bf.

BorderDimensions

BorderDimensions[image] gives the pixel width of uniform borders of image in the form {{left,right},{bottom,top}}.

BorderDimensions[image,t] finds borders whose pixels vary by an amount less than t.

BorelTannerDistribution

BorelTannerDistribution[α,n] represents a Borel–Tanner distribution with shape parameters α and n.

Bottom

Bottom is a symbol that represents the bottom for purposes of alignment and positioning. 

BottomHatTransform

BottomHatTransform[image,ker] gives the morphological bottom-hat transform of image with respect to structuring element ker.

BottomHatTransform[image,r] gives the bottom-hat transform with respect to a range-r square.

BottomHatTransform[data,…] applies a bottom-hat transform to an array of data.

BoundaryDiscretizeGraphics

BoundaryDiscretizeGraphics[g] discretizes a 2D or 3D graphic g into a BoundaryMeshRegion.

BoundaryDiscretizeGraphics[g,patt] discretizes only the elements in g that match the pattern patt.

BoundaryDiscretizeRegion

BoundaryDiscretizeRegion[reg] discretizes the region reg into a BoundaryMeshRegion.

BoundaryDiscretizeRegion[reg,{{xmin,xmax},…}] restricts to the bounds [xmin,xmax]×⋯.

BoundaryMesh

BoundaryMesh[mreg] gives a BoundaryMeshRegion from a MeshRegion mreg. 

BoundaryMeshRegionQ

BoundaryMeshRegionQ[reg] yields True if the region reg is a valid BoundaryMeshRegion object and False otherwise.

BoundaryStyle

BoundaryStyle is an option for plotting functions that specifies the style in which boundaries of regions should be drawn. 

BoundedRegionQ

BoundedRegionQ[reg] gives True if reg is a bounded region and False otherwise. 

BracketingBar

BracketingBar[x, y, …] displays as x,y,….

BrayCurtisDistance

BrayCurtisDistance[u,v] gives the Bray–Curtis distance between vectors u and v.

BreadthFirstScan

BreadthFirstScan[g,s,{event1->f1,event2->f2,…}] performs a breadth-first scan (bfs) of the graph g starting at the vertex s and evaluates fi whenever "eventi" occurs.

BreadthFirstScan[g,{event1->f1,event2->f2,…}] performs a breadth-first scan of the whole graph g.

BreadthFirstScan[{v->w,…},…] uses rules v->w to specify the graph g. 

Break

Break[] exits the nearest enclosing Do, For, Until or While. 

BridgeData

BridgeData[entity,property] gives the value of the specified property for the bridge entity.

BridgeData[{entity1,entity2,…},property] gives a list of property values for the specified bridge entities.

BridgeData[entity,property,annotation] gives the specified annotation associated with the given property.

BrightnessEqualize

BrightnessEqualize[image] adjusts the brightness across image, correcting uneven illumination.

BrightnessEqualize[image,flatfield] uses the correction model given by flatfield, which models the variation in brightness across image.

BrightnessEqualize[image,flatfield,darkfield] uses the dark environment model given by darkfield. 

BroadcastStationData

BroadcastStationData[entity,property] gives the value of the specified property for the broadcast station entity.

BroadcastStationData[{entity1,entity2,…},property] gives a list of property values for the specified broadcast station entities.

BroadcastStationData[entity,property,annotation] gives the specified annotation associated with the given property.

Brown

Brown represents the color brown in graphics or style specifications. 

BrownianBridgeProcess

BrownianBridgeProcess[σ,{t1,a},{t2,b}] represents the Brownian bridge process from value a at time t1 to value b at time t2 with volatility σ.

BrownianBridgeProcess[{t1,a},{t2,b}]  represents the standard Brownian bridge process from value a at time t1 to value b at time t2.

BrownianBridgeProcess[t1,t2]  represents the standard Brownian bridge process pinned at 0 at times t1 and t2.

BrownianBridgeProcess[] represents the standard Brownian bridge process pinned at 0 at time 0 and at time 1.

BSplineCurve

BSplineCurve[{pt1,pt2,…}] is a graphics primitive that represents a nonuniform rational B-spline curve with control points pti.

BSplineFunction

BSplineFunction[{pt1,pt2,…}] represents a B-spline function for a curve defined by the control points pti.

BSplineFunction[array] represents a B-spline function for a surface or high-dimensional manifold. 

BSplineSurface

BSplineSurface[array] is a graphics primitive that represents a nonuniform rational B-spline surface defined by an array of x,y,z control points.

BubbleChart

BubbleChart[{{x1,y1,z1},{x2,y2,z2},…}] makes a bubble chart with bubbles at positions {xi,yi} with sizes zi.

BubbleChart[{…,wi[{xi,yi,zi},…],…,wj[{xj,yj,zj},…],…}] makes a bubble chart with bubble features defined by the symbolic wrappers wk.

BubbleChart[{data1,data2,…}] makes a bubble chart from multiple datasets datai. 

BubbleChart3D

BubbleChart3D[{{x1,y1,z1,u1},{x2,y2,z2,u2},…}] makes a 3D bubble chart with bubbles at positions {xi,yi,zi} with sizes ui.

BubbleChart3D[{…,wi[{xi,yi,zi,ui},…],…,wj[{xj,yj,zj,uj},…],…}] makes a 3D bubble chart with bubble features defined by the symbolic wrappers wk.

BubbleChart3D[{data1,data2,…}] makes a 3D bubble chart from multiple datasets datai. 

BubbleScale

BubbleScale is an option to BubbleChart and related functions that specifies how the scale of each bubble should be determined from the value of each data element.

BubbleSizes

BubbleSizes is an option to BubbleChart and related functions that specifies the range of sizes used for bubbles. 

BuildingData

BuildingData[entity,property] gives the value of the specified property for the building entity.

BuildingData[{entity1,entity2,…},property] gives a list of property values for the specified building entities.

BuildingData[entity,property,annotation] gives the specified annotation associated with the given property.

BulletGauge

BulletGauge[value,reference,{min,max}] draws a bullet gauge showing value and reference in a range of min to max.

BulletGauge[value,reference,{min,m1,m2,…,max}] draws a bullet gauge with performance regions split at the mi.

BulletGauge[{v1,v2,…},…] draws a bullet gauge with multiple values v1, v2, ….

BulletGauge[values,{r1,r2,…},…] draws a bullet gauge with multiple references r1, r2, ….

BusinessDayQ

BusinessDayQ[date] returns True if the date is a business day and returns False otherwise.

ButterflyGraph

ButterflyGraph[n] gives the order-n butterfly graph. 

ButterflyGraph[n,b] gives the base-b order-n butterfly graph. 

ButterworthFilterModel

ButterworthFilterModel[n] creates a lowpass Butterworth filter of order n and cutoff frequency of 1.

ButterworthFilterModel[{n,ωc}] uses the cutoff frequency ωc.

ButterworthFilterModel[{"type",spec}] creates a filter of a given "type" using the specified parameters spec. 

ButterworthFilterModel[{"type",spec},var] expresses the model in terms of the variable var.

Byte

Byte represents a single byte of data in Read. 

ByteArray

ByteArray[{b1,b2,…}] constructs a ByteArray object containing the byte values bi.

ByteArray["string"] constructs a ByteArray object by extracting byte values from a Base64-encoded string.

ByteArrayFormat

ByteArrayFormat[ba] attempts to determine what ImportByteArray format could be used to import the ByteArray object ba.

ByteArrayFormatQ

ByteArrayFormatQ[ba,"fmt"] gives True if the ByteArray object ba might be imported as format "fmt" and gives False otherwise.

ByteArrayFormatQ[ba,{fmt1,fmt2,…}] gives True if ba might be imported as one of "fmti".

ByteArrayQ

ByteArrayQ[expr] gives True if expr is a valid ByteArray object, and False otherwise.

ByteArrayToString

ByteArrayToString[ba] returns a string by decoding the data in the byte array ba, assuming UTF-8 encoding.

ByteArrayToString[ba,"encoding"] interprets the data in the specified character encoding.

ByteOrdering

ByteOrdering is an option for BinaryRead, BinaryWrite, and related functions that specifies what ordering of bytes should be assumed for your computer system.

CalendarConvert

CalendarConvert[date,calendar] converts the date object date to the specified calendar type calendar.

CalendarConvert[date] converts to the default calendar type.

CalendarConvert[{date1,…,daten},calendar] converts date1 through daten to the specified calendar.

CalendarData

CalendarData[cal] gives the default parameters associated with the date calendar cal.

CalendarData[country] gives available holiday calendars for the stock exchanges in the country entity.

CalendarData[cal,param] gives the value of the specified parameter param for calendar cal.

CalendarType

CalendarType is an option that determines the calendar system in which all dates are to be interpreted and output.

CallPacket

CallPacket[integer,list] is a WSTP packet encapsulating a request to invoke the external function numbered integer with the arguments contained in list.

CanberraDistance

CanberraDistance[u,v] gives the Canberra distance between vectors u and v.

Cancel

Cancel[expr] cancels out common factors in the numerator and denominator of expr. 

CandlestickChart

CandlestickChart[{{date1,{open1,high1,low1,close1}},…}] makes a chart with candles representing open, high, low, and close prices for each date. 

CandlestickChart[{"name",daterange}] makes a candlestick chart for the financial entity "name" over the date range daterange. 

CanonicalGraph

CanonicalGraph[g] gives a canonical form of the graph g.

CanonicalGraph[{v->w,…}] uses rules v->w to specify the graph.

CanonicalizePolygon

CanonicalizePolygon[poly] gives a canonical representation of the polygon poly with shared coordinates and with inner and outer boundaries.

CanonicalizePolygon[poly,"filter"] gives a canonical representation of poly with the specified filter.

CanonicalizePolyhedron

CanonicalizePolyhedron[poly] gives a canonical representation of the polyhedron poly with shared coordinates and with inner and outer boundaries.

CanonicalizeRegion

CanonicalizeRegion[reg] gives a canonical representation of the region reg.

CanonicalName

CanonicalName[entity] gives the canonical name for the entity specified by entity.

CanonicalName[{entity1,…,entityn}] gives the canonical name for entity1 through entityn.

CanonicalWarpingCorrespondence

CanonicalWarpingCorrespondence[s1,s2] gives the canonical time warping (CTW) correspondence between sequences s1 and s2.

CanonicalWarpingCorrespondence[s1,s2,warp] uses warp as initial warping correspondence.

CanonicalWarpingCorrespondence[s1,s2,warp,win] uses a window win for local search.

CanonicalWarpingDistance

CanonicalWarpingDistance[s1,s2] gives the canonical time warping (CTW) distance between sequences s1 and s2.

CanonicalWarpingDistance[s1,s2,init] uses init as the initial correspondence between the two sequences.

CanonicalWarpingDistance[s1,s2,init,win] uses a window win for local search.

CantorMesh

CantorMesh[n] gives a mesh region representing the nth-step Cantor set. 

CantorMesh[n,d] gives the nth-step Cantor set in dimension d.

CantorStaircase

CantorStaircase[x] gives the Cantor staircase function FC(x).

Cap

Cap[x,y,…] displays as x⌢y⌢….

CapForm

CapForm[type] is a graphics primitive that specifies what type of caps should be used at the ends of lines, tubes, and related primitives.

CapitalDifferentialD

CapitalDifferentialD[x] displays as x.

Capitalize

Capitalize[string] yields a string in which the first character has been made uppercase.

Capitalize[string,scheme] gives a string capitalized using the specified capitalization scheme.

CapsuleShape

CapsuleShape[{{x1,y1,z1},{x2,y2,z2}},r] represents the filled capsule between points {xi,yi,zi} and radius r.

CarlemanLinearize

CarlemanLinearize[sys,spec] Carleman linearizes the nonlinear state-space model sys according to spec.

CarlsonRC

CarlsonRC[x,y] gives the Carlson's elliptic integral RC(x,y).

CarlsonRD

CarlsonRD[x,y,z] gives the Carlson's elliptic integral RD(x,y,z).

CarlsonRE

CarlsonRE[x,y] gives the Carlson's elliptic integral RE(x,y).

CarlsonRF

CarlsonRF[x,y,z] gives the Carlson's elliptic integral RF(x,y,z).

CarlsonRG

CarlsonRG[x,y,z] gives the Carlson's elliptic integral RG(x,y,z).

CarlsonRJ

CarlsonRJ[x,y,z,ρ] gives Carlson's elliptic integral RJ(x,y,z,ρ).

CarlsonRK

CarlsonRK[x,y] gives the Carlson's elliptic integral RK(x,y).

CarlsonRM

CarlsonRM[x,y,ρ] gives Carlson's elliptic integral RM(x,y,ρ).

CarmichaelLambda

CarmichaelLambda[n] gives the Carmichael function λ(n).

CaseOrdering

CaseOrdering is an option for AlphabeticSort and related functions that specifies how upper versus lower case should be sorted.

Cases

Cases[{e1,e2,…},pattern] gives a list of the ei that match the pattern. 

Cases[{e1,…},pattern->rhs] gives a list of the values of rhs corresponding to the ei that match the pattern. 

Cases[expr,pattern,levelspec] gives a list of all parts of expr on levels specified by levelspec that match the pattern. 

Cases[expr,pattern->rhs,levelspec] gives the values of rhs that match the pattern. 

Cases[expr,pattern,levelspec,n] gives the first n parts in expr that match the pattern. 

Cases[pattern] represents an operator form of Cases that can be applied to an expression.

CaseSensitive

CaseSensitive[patt] represents a string pattern that requires matching typographical case, even with the overall option setting IgnoreCase->True.

Cashflow

Cashflow[{c0,c1,…,cn}] represents a series of cash flows occurring at unit time intervals.

Cashflow[{c0,c1,…,cn},q] represents cash flows occurring at time intervals q.

Cashflow[{{time1,c1},{time2,c2},…}] represents cash flows occurring at the specified times.

Casoratian

Casoratian[{y1,y2,…},n] gives the Casoratian determinant for the sequences y1, y2, … depending on n.

Casoratian[eqn,y,n] gives the Casoratian determinant for the basis of the solutions of the linear difference equation eqn involving y[n+m]. 

Casoratian[eqns,{y1,y2,…},n] gives the Casoratian determinant for the system of linear difference equations eqns.

Catalan

Catalan is Catalan's constant, with numerical value ≃0.915966. 

CatalanNumber

CatalanNumber[n] gives the nth Catalan number Cn.

Catch

Catch[expr] returns the argument of the first Throw generated in the evaluation of expr. 

Catch[expr,form] returns value from the first Throw[value,tag] for which form matches tag. 

Catch[expr,form,f] returns f[value,tag]. 

CategoricalDistribution

CategoricalDistribution[{c1,c2,…}] represents a uniform categorical distribution over classes c1, c2, etc.

CategoricalDistribution[{c1,c2,…},{w1,w2,…}] represents a categorical distribution over classes ci with weights wi.

CategoricalDistribution[{{a1,a2,…},{b1,b2,…},…}] represents a uniform multivariate categorical distribution over domain {a1,a2,…}×{b1,b2,…}×….

CategoricalDistribution[domain,weights] uses the array weights to define probabilities over each element of the domain.

Catenate

Catenate[{list1,list2,…}] yields a single list with all elements from the listi in order. 

Catenate[{assoc1,assoc2,…}] yields a list of all values in order appearing in the associations associ.

CatenateLayer

CatenateLayer[] represents a net layer that takes a list of input arrays and catenates them.

CatenateLayer[n] represents a net layer that takes a list of input arrays and catenates them at level n.

CauchyDistribution

CauchyDistribution[a,b] represents a Cauchy distribution with location parameter a and scale parameter b.

CauchyDistribution[] represents a Cauchy distribution with location parameter 0 and scale parameter 1.

CauchyWindow

CauchyWindow[x] represents a Cauchy window function of x.

CauchyWindow[x,α] uses the parameter α.

CayleyGraph

CayleyGraph[group] returns a Cayley graph representation of group.

CDFWavelet

CDFWavelet[] represents a Cohen–Daubechies–Feauveau wavelet of type "9/7". 

CDFWavelet["type"] represents a Cohen–Daubechies–Feauveau wavelet of type "type". 

Ceiling

Ceiling[x] gives the smallest integer greater than or equal to x. 

Ceiling[x,a] gives the smallest multiple of a greater than or equal to x. 

CensoredDistribution

CensoredDistribution[{xmin,xmax},dist] represents the distribution of values that come from dist and are censored to be between xmin and xmax.

CensoredDistribution[{{xmin,xmax},{ymin,ymax},…},dist] represents the distribution of values that come from the multivariate distribution dist and are censored to be between xmin and xmax, ymin and ymax, etc.

Censoring

Censoring[t,c] represents a censored event time t with censoring c.

Censoring[{t1,t2,…},c] represents a vector of censored event times ti with censoring c.

Censoring[{t1,t2,…},{c1,c2,…}] represents a vector of event times ti with corresponding censoring ci.

Center

Center is a symbol that represents the center for purposes of alignment and positioning. 

CenterArray

CenterArray[a,n] creates a list of length n with the elements of a at the center and zeros elsewhere.

CenterArray[a,{n1,n2,…}] creates an n1×n2×… array with the array a at the center and zeros elsewhere.

CenterArray[a,nspec,pad] uses pad instead of zero for the background.

CenterArray[nspec] creates an array with a single 1 at the center and zeros elsewhere.

CenterDot

CenterDot[x,y,…] displays as x·y·….

CenteredInterval

CenteredInterval[x,dx] for real numbers x and dx gives a centered interval that contains the real interval {a∈|x-dx≤a≤x+dx}.

CenteredInterval[x+ y,dx+ dy] gives a centered interval that contains the complex rectangle {a+ b∈|x-dx≤a≤x+dx∧y-dy≤b≤y+dy}.

CenteredInterval[c] for an approximate number c gives a centered interval that contains all values within the error bounds of c.

CentralFeature

CentralFeature[{x1,x2,…}] gives the central feature of the elements xi.

CentralFeature[{x1->v1,x2->v2,…}] gives the vi corresponding to the central feature xi.

CentralFeature[data] gives the central feature for several different forms of data.

CentralMoment

CentralMoment[data,r] gives the order r central moment μ&~r of data.

CentralMoment[data,{r1,…,rm}] gives the order {r1,…,rm} multivariate central moment μ&~r1, …, rm of data.

CentralMoment[dist,…] gives the central moment of the distribution dist.

CentralMoment[r] represents the order r formal central moment.

CentralMomentGeneratingFunction

CentralMomentGeneratingFunction[dist,t] gives the central moment-generating function for the distribution dist as a function of the variable t. 

CentralMomentGeneratingFunction[dist,{t1,t2,…}] gives the central moment-generating function for the multivariate distribution dist as a function of the variables t1, t2, …. 

Cepstrogram

Cepstrogram[data] plots the array of power cepstra computed on each partition of data.

Cepstrogram[data,n] uses partitions of length n.

Cepstrogram[data,n,d] uses partitions with offset d.

Cepstrogram[data,n,d,wfun] applies a smoothing window wfun to each partition.

Cepstrogram[data,n,d,wfun,m] pads partitions with zeros to length m prior to the computation of the transform.

CepstrogramArray

CepstrogramArray[data] computes an array of cepstra on data.

CepstrogramArray[data,n] uses partitions of length n.

CepstrogramArray[data,n,d] uses partitions with offset d.

CepstrogramArray[data,n,d,wfun] applies a smoothing window wfun to each partition.

CepstrogramArray[data,n,d,wfun,m] pads partitions with zeros to length m prior to the computation of the transform.

CepstrumArray

CepstrumArray[data] computes the power cepstrum of data.

CepstrumArray[data,type] computes the specified type of cepstrum of data.

CForm

CForm[expr] prints as a C language version of expr. 

ChampernowneNumber

ChampernowneNumber[b] gives the base-b Champernowne number Cb.

ChampernowneNumber[] gives the base-10 Champernowne number.

ChannelBase

ChannelBase is an option specifying the base URL of the server to use for brokering channel communications.

ChannelBrokerAction

ChannelBrokerAction is an option specifying the action to execute on the channel broker server in addition to routing a message.

ChannelHistoryLength

ChannelHistoryLength is an option to ChannelListen that specifies the maximum number of messages to cache in the channel listener object. 

ChannelListen

ChannelListen[channel] starts listening on the specified channel.

ChannelListen[channel,func] applies func to the association corresponding to each message received on the channel.

ChannelListen[channel,None] stores each message received on the channel, without applying any function.

ChannelListen[url] listens on the specified URL, storing messages received, without requiring an explicit channel to exist on the channel broker.

ChannelListener

ChannelListener[…] represents a channel listener created by ChannelListen.

ChannelListeners

ChannelListeners[] gives a list of currently active channel listeners.

ChannelObject

ChannelObject[] gives a new anonymous channel specification.

� represents a channel specified by a given URL.

ChannelObject["relpath"] represents a channel for the currently authenticated user at a relative path.

ChannelObject["id:�] represents a channel for the user with the specified Wolfram ID at the given path.

ChannelObject["/�] represents a channel at an absolute path on the channel broker.

ChannelReceiverFunction

ChannelReceiverFunction[fun] represents a channel receiver function that applies fun to any channel message it receives.

ChannelSend

ChannelSend[channel,msg] sends the specified message msg to the specified channel.

ChannelSubscribers

ChannelSubscribers[channel] gives a list of users currently subscribed to the specified channel.

ChannelSubscribers[{channel1,channel2,…}] gives a list of subscribed users for each of the channels channeli.

ChanVeseBinarize

ChanVeseBinarize[image] finds a two-level segmentation of image by computing optimal contours around regions of consistent intensity in image.

ChanVeseBinarize[image,marker] uses marker to create an initial contour.

ChanVeseBinarize[image,marker,{μ,ν,λ1,λ2}] specify the Chan–Vese weights μ, ν, λ1, and λ2.

Character

Character represents a single character in Read. 

CharacterCounts

CharacterCounts["string"] gives an association whose keys are the distinct characters in string, and whose values give the number of times those characters appear in string.

CharacterCounts["string",n] gives counts of the distinct n-grams consisting of runs of n characters in string.

CharacterCounts[{string1,string2,…},…] gives the counts for each of the stringi.

CharacterEncoding

CharacterEncoding is an option for input and output functions which specifies what raw character encoding should be used. 

CharacterEncodingsPath

CharacterEncodingsPath is a global option that specifies which directories are searched for character encoding files.

CharacteristicFunction

CharacteristicFunction[dist,t] gives the characteristic function for the distribution dist as a function of the variable t.

CharacteristicFunction[dist,{t1,t2,…}] gives the characteristic function for the multivariate distribution dist as a function of the variables t1, t2, ….

CharacteristicPolynomial

CharacteristicPolynomial[m,x] gives the characteristic polynomial for the matrix m. 

CharacteristicPolynomial[{m,a},x] gives the generalized characteristic polynomial with respect to a. 

CharacterName

CharacterName["c"] gives the name of the character c.

CharacterName[n] gives the name of the character with character code n.

CharacterName[c,"type"] gives a name of the specified type.

CharacterNormalize

CharacterNormalize["text",form] converts the characters in text to the specified normalization form.

CharacterRange

CharacterRange[c1,c2] yields a list of the characters in the range from "c1" to "c2". 

CharacterRange[n1,n2] yields a list of the characters with character codes in the range n1 to n2.

Characters

Characters["string"] gives a list of the characters in a string. 

ChartBaseStyle

ChartBaseStyle is an option for charting functions that specifies the base style for all chart elements.

ChartElementFunction

ChartElementFunction is an option for charting functions such as BarChart that gives a function to use to generate the primitives for rendering each chart element.

ChartElements

ChartElements is an option to charting functions such as BarChart that specifies the graphics to use as the basis for bars or other chart elements. 

ChartLabels

ChartLabels is an option for charting functions that specifies what labels should be used for chart elements.

ChartLayout

ChartLayout is an option to charting functions that specifies the overall layout to use.

ChartLegends

ChartLegends is an option for charting functions that specifies what legends should be used for chart elements. 

ChartStyle

ChartStyle is an option for charting functions that specifies styles in which chart elements should be drawn.

Chebyshev1FilterModel

Chebyshev1FilterModel[n] creates a lowpass Chebyshev type 1 filter of order n.

Chebyshev1FilterModel[{n,ωc}] uses the cutoff frequency ωc.

Chebyshev1FilterModel[{"type",spec}] creates a filter of a given "type" using the specified parameters spec. 

Chebyshev1FilterModel[{"type",spec},var] expresses the model in terms of the variable var.

Chebyshev2FilterModel

Chebyshev2FilterModel[n] creates a lowpass Chebyshev type 2 filter of order n.

Chebyshev2FilterModel[{n,ωc}] uses the cutoff frequency ωc.

Chebyshev2FilterModel[{"type",spec}] uses the full filter specification {"type",spec}.

Chebyshev2FilterModel[{"type",spec},var] expresses the model in terms of the variable var.

ChebyshevDistance

ChebyshevDistance[u,v] gives the Chebyshev or sup norm distance between vectors u and v.

ChebyshevT

ChebyshevT[n,x] gives the Chebyshev polynomial of the first kind Tn(x). 

ChebyshevU

ChebyshevU[n,x] gives the Chebyshev polynomial of the second kind Un(x). 

Check

Check[expr,failexpr] evaluates expr, and returns the result, unless messages were generated, in which case it evaluates and returns failexpr. 

Check[expr,failexpr,{s1::t1,s2::t2,…}] checks only for the specified messages. 

Check[expr,failexpr,"name"] checks only for messages in the named message group.

CheckAbort

CheckAbort[expr,failexpr] evaluates expr, returning failexpr if an abort occurs. 

CheckAll

CheckAll[expr,f] evaluates expr and returns f[expr,HoldComplete[control1,…]] where the controli expressions are aborts, throws, or other flow control commands currently being executed (but stopped by CheckAll).

CheckArguments

CheckArguments[f[args],n] gives True if args consists of exactly n positional arguments followed by valid options for f, and False otherwise.

CheckArguments[f[args],{min,max}] requires the number of positional arguments to be between min and max.

CheckArguments[f[args],spec,assoc] modifies the behavior based on the information in the association assoc.

ChemicalData

ChemicalData["name","property"] gives the value of the specified property for the chemical "name".

ChemicalData["name"] gives a structure diagram for the chemical with the specified name.

ChemicalData["class"] gives a list of available chemicals in the specified class.

ChemicalFormula

ChemicalFormula[<|elem1->n1,elem2->n2,…|>] represents a chemical species with ni atoms of the element elemi.

ChemicalFormula[chem] returns the chemical formula corresponding to the given input.

ChemicalFormula[…,<|qual1->val1,qual2->val2 …|>] represents a species whose qualifiers quali have values vali.

ChemicalReaction

ChemicalReaction[reactants->products] represents a chemical reaction between the given reactants and products.

ChessboardDistance

ChessboardDistance[u,v] gives the chessboard, Chebyshev, or sup norm distance between vectors u and v.

ChiDistribution

ChiDistribution[ν] represents a χ distribution with ν degrees of freedom.

ChineseRemainder

ChineseRemainder[{r1,r2,…},{m1,m2,…}] gives the smallest x with x≥0 that satisfies all the integer congruences x mod mirimod mi.

ChineseRemainder[{r1,r2,…},{m1,m2,…},d] gives the smallest x with x≥d that satisfies all the integer congruences x mod mirimod mi.

ChiSquareDistribution

ChiSquareDistribution[ν] represents a χ2 distribution with ν degrees of freedom.

CholeskyDecomposition

CholeskyDecomposition[m] gives the Cholesky decomposition of a matrix m. 

Chop

Chop[expr] replaces approximate real numbers in expr that are close to zero by the exact integer 0. 

Chop[expr,delta] replaces numbers smaller in absolute magnitude than delta by 0.

ChromaticityPlot

ChromaticityPlot[colspace] plots a 2D slice of the color space colspace. 

ChromaticityPlot[color] plots the specific color.

ChromaticityPlot[{col1,col2,…}] plots multiple colors and color spaces.

ChromaticityPlot[image] plots the pixels of image as individual colors.

ChromaticityPlot[…,refcolspace] uses the reference color space refcolspace.

ChromaticityPlot3D

ChromaticityPlot3D[colspace] returns a 3D gamut of the color space colspace.

ChromaticityPlot3D[color] plots the specific color.

ChromaticityPlot3D[image] plots the pixels of image as individual colors.

ChromaticityPlot3D[{input1,input2,…}] plots multiple colors, color spaces and images.

ChromaticityPlot3D[…,refcolspace] uses the reference color space refcolspace.

ChromaticPolynomial

ChromaticPolynomial[g,k] gives the chromatic polynomial of the graph g.

ChromaticPolynomial[{v->w,…},…] uses rules v->w to specify the graph g. 

Circle

Circle[{x,y},r] represents a circle of radius r centered at {x,y}.

Circle[{x,y}] gives a circle of radius 1. 

Circle[{x,y},{rx,ry}] gives an axis-aligned ellipse with semiaxes lengths rx and ry.

Circle[{x,y},…,{θ1,θ2}] gives a circular or ellipse arc from angle θ1 to θ2.

CircleDot

CircleDot[x,y,…] displays as x⊙y⊙….

CircleMinus

CircleMinus[x,y] displays as x⊖y. 

CirclePlus

CirclePlus[x,y,…] displays as x⊕y⊕….

CirclePoints

CirclePoints[n] gives the positions of n points equally spaced around the unit circle.

CirclePoints[r,n] gives the positions of n points equally spaced around a circle of radius r.

CirclePoints[{r,θ1},n] starts at angle θ1 with respect to the x axis.

CirclePoints[{x,y},rspec,n] centers the circle at {x,y}.

CircleThrough

CircleThrough[{p1,p2,…}] represents a circle passing through the points pi.

CircleThrough[{p1,p2,…},q] represents a circle with center q.

CircleThrough[{p1,p2,…},q,r] represents a circle with radius r.

CircleTimes

CircleTimes[x] displays as ⊗x.

CircleTimes[x,y,…] displays as x⊗y⊗….

CirculantGraph

CirculantGraph[n,j] gives the circulant graph Cn(j) with n vertices and jump j.

CirculantGraph[n,{j1,j2,…}] gives the circulant graph Cn(j1,j2,…) with n vertices and jumps j1, j2, ….

CircularOrthogonalMatrixDistribution

CircularOrthogonalMatrixDistribution[n] represents a circular orthogonal matrix distribution with matrix dimensions {n,n}.

CircularQuaternionMatrixDistribution

CircularQuaternionMatrixDistribution[n] represents a circular quaternion matrix distribution with matrix dimensions {2 n,2 n} over the field of complex numbers.

CircularRealMatrixDistribution

CircularRealMatrixDistribution[n] represents a circular real matrix distribution with matrix dimensions {n,n}.

CircularSymplecticMatrixDistribution

CircularSymplecticMatrixDistribution[n] represents a circular symplectic matrix distribution with matrix dimensions {2 n,2 n} over the field of complex numbers.

CircularUnitaryMatrixDistribution

CircularUnitaryMatrixDistribution[n] represents a circular unitary matrix distribution with matrix dimensions {n,n}.

Circumsphere

Circumsphere[{p1,…,pn+1}] gives the sphere that circumscribes the points pi in n.

Circumsphere[poly] gives the circumsphere of a polyhedron or polygon poly.

CityData

CityData[name,"property"] gives the value of the specified property for the city with the specified name.

CityData[name] gives a list of the full specifications of cities whose names are consistent with name.

ClassifierFunction

ClassifierFunction[…] represents a function generated by Classify that classifies data into classes.

ClassifierInformation

ClassifierInformation[classifier] generates a report giving information on the classifier function classifier.

ClassifierInformation[classifier,prop] gives information for classifier associated with property prop.

ClassifierMeasurements

ClassifierMeasurements[classifier,testset,prop] gives measurements associated with property prop when classifier is evaluated on testset.

ClassifierMeasurements[classifier,testset] yields a measurement report that can be applied to any property.

ClassifierMeasurements[data,…] uses classifications data instead of a classifier.

ClassifierMeasurements[…,{prop1,prop2,…}] gives properties prop1, prop2, etc.

ClassifierMeasurementsObject

ClassifierMeasurementsObject[…] represents an object generated by ClassifierMeasurements that can be applied to properties.

Classify

Classify[{in1->class1,in2->class2,…}] generates a ClassifierFunction that attempts to predict classi from the example ini.

Classify[data,input] attempts to predict the output associated with input from the training examples given.

Classify[data,input,prop] computes the specified property prop relative to the prediction.

ClassPriors

ClassPriors is an option for Classify and related functions that specifies explicit prior probabilities to assume for output classes, independent of anything deduced from the training set.

Clear

Clear[s1,s2,…] clears values and definitions for the symbols si. 

Clear[patt1,patt2,…] clears values and definitions for all symbols whose names textually match any of the arbitrary string patterns patti.

Clear[{spec1,spec2,…}] clears values and definitions for any symbols that are equal to or whose names match any of the speci.

ClearAll

ClearAll[s1,s2,…] clears all values, definitions, attributes, defaults, options and messages for the symbols si.

ClearAll[patt1,patt2,…] clears all symbols whose names textually match any of the arbitrary string patterns patti.

ClearAll[{spec1,spec,…}] clears any symbols that are equal to or whose names match any of the speci.

ClearAttributes

ClearAttributes[symbol,attr] removes attr from the list of attributes of the symbol symbol. 

ClearAttributes["symbol",attr] removes attr from the attributes of the symbol named "symbol" if it exists.

ClearAttributes[s,{attr1,attr2,…}] removes several attributes at a time.

ClearAttributes[{s1,s2,…},attrs] removes attributes from several symbols at a time.

ClearCookies

ClearCookies[domain] clears all persistent and session cookies associated with the specified domain.

ClearCookies[assoc] clears all cookies whose attributes match the specification in the association assoc.

ClearCookies[All] clears all persistent and session cookies for all domains.

ClebschGordan

ClebschGordan[{j1,m1},{j2,m2},{j,m}] gives the Clebsch–Gordan coefficient for the decomposition of j,m〉 in terms of j1,m1〉j2,m2〉. 

ClickPane

ClickPane[image,func] represents a clickable pane that displays as image and applies func to the x,y coordinates of each click within the pane.

ClickPane[image,{{xmin,ymin},{xmax,ymax}},func] specifies the range of coordinates to use.

ClickToCopy

ClickToCopy[expr] represents a button that copies expr whenever it is clicked.

ClickToCopy[label,expr] displays with label on the button.

ClickToCopyEnabled

ClickToCopyEnabled is an option for Cell that specifies whether to show a click-to-copy overlay when hovering over a cell.

Clip

Clip[x] gives x clipped to be between -1 and +1. 

Clip[x,{min,max}] gives x for min≤x≤max, min for x<min and max for x>max. 

Clip[x,{min,max},{vmin,vmax}] gives vmin for x<min and vmax for x>max. 

ClipFill

ClipFill is an option for plotting functions that specifies what should be shown where curves or surfaces would extend beyond the plot range. 

ClippingStyle

ClippingStyle is an option for plotting functions that specifies the style of what should be drawn when curves or surfaces would extend beyond the plot range. 

ClipPlanes

ClipPlanes is an option to Graphics3D that specifies a list of clipping planes that can cut away portions of a 3D scene from the resulting view.

ClipPlanesStyle

ClipPlanesStyle is an option to Graphics3D that specifies how clipping planes defined with the ClipPlanes option should be rendered.

ClipRange

ClipRange is an option to Raster3D that specifies a rectangular region that is cut away from the resulting view.

ClockGauge

ClockGauge[] draws an analog clock face showing the local time with hours, minutes, and seconds.

ClockGauge[time] draws an analog clock face showing the time corresponding to an AbsoluteTime, DateObject, or TimeObject specification.

ClockGauge[{h,m,s}] draws an analog clock face showing hour h, minute m, and seconds s.

ClockGauge[{y,m,d,h,m,s}] draws an analog clock face showing the time corresponding to the date list in a DateList specification.

ClockGauge["string"] draws an analog clock face showing the time DateList["string"].

Close

Close[obj] closes a stream or socket. 

CloseKernels

CloseKernels[] terminates all parallel kernels from the list ParallelKernels[].

CloseKernels[k] terminates the kernel k.

CloseKernels[{k1,k2,…}] terminates the kernels k1, k2, ….

CloseKernels["prop"] terminates kernels that satisfy the given property.

ClosenessCentrality

ClosenessCentrality[g] gives a list of closeness centralities for the vertices in the graph g.

ClosenessCentrality[{v->w,…}] uses rules v->w to specify the graph g. 

Closing

Closing[image,ker] gives the morphological closing of image with respect to the structuring element ker.

Closing[image,r] gives the closing with respect to a range-r square.

Closing[data,…] applies closing to an array of data.

ClusterClassify

ClusterClassify[data] generates a ClassifierFunction[…] by partitioning data into clusters of similar elements.

ClusterClassify[data,n] generates a ClassifierFunction[…] with n clusters.

ClusterDissimilarityFunction

ClusterDissimilarityFunction is an option for ClusteringTree and Dendrogram that specifies the intercluster dissimilarity.

ClusteringComponents

ClusteringComponents[array] gives an array in which each element at the lowest level of array is replaced by an integer index representing the cluster in which the element lies.

ClusteringComponents[array,n] finds n clusters.

ClusteringComponents[array,n,level] finds clusters at the specified level in array.

ClusteringComponents[image] finds clusters of pixels with similar values in image.

ClusteringComponents[image,n] finds n clusters in image.

ClusteringTree

ClusteringTree[{e1,e2,…}] constructs a weighted tree from the hierarchical clustering of the elements e1, e2, ….

ClusteringTree[{e1->v1,e2->v2,…}] represents ei with vi in the constructed graph.

ClusteringTree[{e1,e2,…}->{v1,v2,…}] represents ei with vi in the constructed graph.

ClusteringTree[<|label1->e1,label2->e2…|>] represents ei using labels labeli in the constructed graph.

ClusteringTree[data,h] constructs a weighted tree from the hierarchical clustering of data by joining subclusters at distance less than h. 

CMYKColor

CMYKColor[c,m,y,k] represents a color in the CMYK color space with cyan, magenta, yellow and black components.

CMYKColor[c,m,y,k,a] specifies opacity a. 

CMYKColor["string"] returns a color from an HTML color name etc.

CMYKColor[color] returns the CMYK representation of color.

Coefficient

Coefficient[expr,form] gives the coefficient of form in the polynomial expr. 

Coefficient[expr,form,n] gives the coefficient of form^n in expr. 

CoefficientArrays

CoefficientArrays[polys,vars] gives the arrays of coefficients of the variables vars in the polynomials polys. 

CoefficientList

CoefficientList[poly,var] gives a list of coefficients of powers of var in poly, starting with power 0. 

CoefficientList[poly,{var1,var2,…}] gives an array of coefficients of the vari. 

CoefficientList[poly,{var1,var2,…},{dim1,dim2,…}] gives an array of dimensions {dim1,dim2,…}, truncating or padding with zeros as needed.

CoefficientRules

CoefficientRules[poly,{x1,x2,…}] gives the list {{e11,e12,…}->c1,{e21,…}->c2,…} of exponent vectors and coefficients for the monomials in poly with respect to the xi.

CoefficientRules[poly,{x1,x2,…},order] gives the result with the monomial ordering specified by order.

CoifletWavelet

CoifletWavelet[] represents a Coiflet wavelet of order 2.

CoifletWavelet[n] represents a Coiflet wavelet of order n.

Collect

Collect[expr,x] collects together terms involving the same powers of objects matching x. 

Collect[expr,{x1,x2,…}] successively collects together terms that involve the same powers of objects matching x1, then x2, …. 

Collect[expr,var,h] applies h to the expression that forms the coefficient of each term obtained. 

CollinearPoints

CollinearPoints[{p1,p2,p3,…,pn}] tests whether the points p1,p2,p3,…,pn are collinear.

Colon

Colon[x,y,…] displays as x∶y∶….

ColonForm

ColonForm[a,b] prints as a: b.

ColorBalance

ColorBalance[image] adjusts the colors in image to achieve a balance that simulates the effect of neutral lighting.

ColorBalance[image,ref] adjusts colors in image so that the reference color specified by ref is mapped to white. 

ColorBalance[image,ref->target] maps the reference color ref to target.

ColorCombine

ColorCombine[{image1,image2,…}] creates a multichannel image by combining the sequence of channels in the imagei. 

ColorCombine[{image1,image2,…},colorspace] combines images that represent the color components specified by colorspace.

ColorConvert

ColorConvert[color,colspace] converts the color space of a color to the specified color space colspace.

ColorConvert[image,colspace] converts the color space of image.

ColorConvert[{expr1,…},colspace] converts the color space of a list of colors and images.

ColorCoverage

ColorCoverage is an option for DominantColors that specifies the minimum image coverage that each color cluster should have.

ColorData

ColorData["scheme"] gives a function that generates colors in the named color scheme when applied to parameter values. 

ColorData["scheme","property"] gives the specified property of a color scheme.

ColorData["collection"] gives a list of color schemes in a named collection.

ColorData[] gives a list of named collections of color schemes.

ColorDataFunction

ColorDataFunction[range,…] is a function that represents a color scheme. 

ColorDetect

ColorDetect[image,cspec] returns a mask image representing regions in image with colors within the specified color region.

ColorDistance

ColorDistance[c1,c2] gives the approximate perceptual distance between color directives c1 and c2.

ColorDistance[list,c] gives color distances between elements of list and c.

ColorDistance[list1,list2] gives color distances between corresponding elements of list1 and list2.

ColorDistance[image,c] gives an image whose pixel values are color distance between pixels in image and the color c.

ColorDistance[image1,image2] yields an image giving the pixelwise color distance between image1 and image2.

ColorFunction

ColorFunction is an option for graphics functions that specifies a function to apply to determine colors of elements. 

ColorFunctionBinning

ColorFunctionBinning is an option for plotting functions that divides values into a limited set of bins for styling.

ColorFunctionScaling

ColorFunctionScaling is an option for graphics functions that specifies whether arguments supplied to a color function should be scaled to lie between 0 and 1. 

Colorize

Colorize[m] generates an image from an integer matrix m, using colors for positive integers and black for non-positive integers.

Colorize[image] replaces intensity values in image with pseudocolor values.

ColorNegate

ColorNegate[color] gives the negative of a color.

ColorNegate[image] gives the negative of image, in which all colors have been negated.

ColorNegate[video] negates every frame of a video.

ColorNegate[{expr1,…}] gives a list of negative images or colors.

ColorOutput

ColorOutput is an option for graphics functions that specifies the type of color output to produce. 

ColorProfileData

ColorProfileData[<>,"Description"->"desc","DeviceColorSpace"->"device","IndependentColorSpace"->"ics"] represents an ICC color profile that can convert between the independent color space "ics" and the device-dependent color space "device".

ColorQ

ColorQ[color] yields True if color is a valid color directive and False otherwise.

ColorQuantize

ColorQuantize[image] gives an approximation to image by quantizing to distinct colors.

ColorQuantize[image,n] uses at most n distinct colors.

ColorQuantize[image,{col1,…,coln}] represents an image using only the n specified colors coli.

ColorReplace

ColorReplace[image,color] finds regions in image whose pixel values are similar to color and replaces them with transparent pixels.

ColorReplace[image,color->replacement] replaces all pixels with the specified replacement color.

ColorReplace[image,color->replacement,d] replaces all pixels whose values are within a distance d from color.

ColorReplace[image,{color1->replacement1,…},{d1,…}] does multiple color replacements.

ColorSeparate

ColorSeparate[image] gives a list of single-channel images corresponding to each of the color channels in image.

ColorSeparate[image,colorspace] gives a list of images corresponding to the components of colorspace.

ColorSeparate[image,channel] returns a single-channel image containing the specified channel.

ColorsNear

ColorsNear[color] represents a region around color.

ColorsNear[color,d] represents a region with maximum distance d around color.

ColorsNear[color,d,dfun] uses the specified color distance function dfun.

ColorSpace

ColorSpace is an option for Image and related functions that specifies the color space to which color values refer.

ColorToneMapping

ColorToneMapping[image] applies a tone mapping to color values in image so as to make variations of luminance visible even in small intervals of the dynamic range. 

ColorToneMapping[image,c] maps colors by compressing the overall range of luminance values by a factor c.

ColorToneMapping[image,range] applies a mapping only to colors whose initial luminance lies in the specified range.

ColorToneMapping[image,{range,c}] takes the specified range of colors and compresses their overall luminance values by a factor c.

ColorToneMapping[image,{{range1,c1},{range2,c2},…}] uses different compression factors ci for different ranges rangei. 

ColorToneMapping[image,spec,s] uses the color compensation factor s to correct for saturation distortion introduced during tone mapping.

Column

Column[{expr1,expr2,…}] is an object that formats with the expri arranged in a column, with expr1 above expr2, etc. 

Column[list,alignment] aligns each element horizontally in the specified way. 

Column[list,alignment,spacing] leaves the specified number of x-heights of spacing between successive elements.

ColumnForm

ColumnForm[{e1,e2,…}] prints as a column with e1 above e2, etc. 

ColumnForm[list,horiz] specifies the horizontal alignment of each element. 

ColumnForm[list,horiz,vert] also specifies the vertical alignment of the whole column. 

CombinatorB

CombinatorB represents the <b>B</b> combinator.

CombinatorC

CombinatorC represents the <b>C</b> combinator.

CombinatorI

CombinatorI represents the <b>I</b> combinator.

CombinatorK

CombinatorK represents the <b>K</b> combinator.

CombinatorS

CombinatorS represents the <b>S</b> combinator.

CombinatorW

CombinatorW represents the <b>W</b> combinator.

CombinatorY

CombinatorY represents the <b>Y</b> combinator.

CombinedEntityClass

CombinedEntityClass[class1,class2,prop] represents a class of entities obtained by combining the properties of those pairs of entities from class1 and class2 for which the value of the property prop is the same for the two entities in the pair.

CombinedEntityClass[class1,class2,prop1->prop2] combines pairs of entities from class1 and class2 for which the value of prop1 of the entity from class1 is the same as the value of prop2 for the entity from class2. 

CombinedEntityClass[class1,class2,{pspeca,pspecb,…}] combines pairs of entities for which all the property specifications pspeck agree.

CombinedEntityClass[class1,class2,f] combines pairs of entities for which the application of the entity function f yields True. 

CombinedEntityClass[class1,class2,spec,"jspec"] uses "jspec" to determine when to allow entities with missing properties to be included.

CombinerFunction

CombinerFunction is an option for template functions that specifies how fragments should be assembled to give the result of applying a template.

CometData

CometData[entity,property] gives the value of the specified property for the comet entity.

CometData[{entity1,entity2,…},property] gives a list of property values for the specified comet entities.

CometData[entity,property,annotation] gives the specified annotation associated with the given property.

Commonest

Commonest[list] gives a list of the elements that are the most common in list.

Commonest[list,n] gives a list of the n most common elements in list.

CommonName

CommonName[entity] gives the common name for the entity specified by entity.

CommonName[{entity1,…,entityn}] gives the common name for entity1 through entityn.

CommonUnits

CommonUnits[{quantity1,quantity2,…,quantityn}] converts quantity1 through quantityn to common units across compatible dimensions.

CommunityBoundaryStyle

CommunityBoundaryStyle is an option to CommunityGraphPlot that specifies how to style community boundaries.

CommunityGraphPlot

CommunityGraphPlot[g] generates a plot showing the community structure of the graph g.

CommunityGraphPlot[g,{{vi1,vi2,…},…}] generates a plot for the graph g with communities {vi1,vi2,…}, ….

CommunityGraphPlot[g,{…,wj[{vi1,…}],…}] generates a plot with highlighting features defined by the symbol wrappers wj.

CommunityGraphPlot[{vi1->vj1,vi2->vj2,…},…] generates a plot for a graph in which vertex vik is connected to vertex vjk.

CommunityGraphPlot[m,…] generates a plot for a graph represented by the adjacency matrix m.

CommunityLabels

CommunityLabels is an option to CommunityGraphPlot that controls what labels and placement to use for communities. 

CommunityRegionStyle

CommunityRegionStyle is an option to CommunityGraphPlot that specifies how to style community regions.

CompanyData

CompanyData[entity,property] gives the value of the specified property for the company entity.

CompanyData[{entity1,entity2,…},property] gives a list of property values for the specified company entities.

CompanyData[entity,property,annotation] gives the specified annotation associated with the given property.

CompatibleUnitQ

CompatibleUnitQ[quantity1,quantity2] returns True if quantity1 and quantity2 have compatible units, and False otherwise.

CompilationOptions

CompilationOptions is an option for Compile that specifies settings for the compilation process. 

CompilationTarget

CompilationTarget is an option for Compile that specifies the target runtime for the compiled function. 

Compile

Compile[{x1,x2,…},expr] creates a compiled function that evaluates expr assuming numerical values of the xi. 

Compile[{{x1,t1},…},expr] assumes that xi is of a type that matches ti. 

Compile[{{x1,t1,n1},…},expr] assumes that xi is a rank ni array of objects, each of a type that matches ti. 

Compile[vars,expr,{{p1,pt1},…}] assumes that subexpressions in expr that match pi are of types that match pti. 

Compiled

Compiled is an option for various numerical and plotting functions which specifies whether the expressions they work with should automatically be compiled. 

CompiledCodeFunction

CompiledCodeFunction[…] is a function created by FunctionCompile that contains compiled code that is run when the CompiledCodeFunction is applied to suitable arguments. 

CompiledFunction

CompiledFunction[�] represents compiled code for evaluating a compiled function. 

CompiledLayer

CompiledLayer[func] represents a net layer whose computation is defined by the compilable function func.

CompiledLayer[func,gradientfunc] specifies a gradient propagating function allowing the layer to be used in NetTrain.

CompilerEnvironment

CompilerEnvironment is an option for FunctionCompile and related functions that allows definitions to be included in the compilation. 

CompilerEnvironmentAppendTo

CompilerEnvironmentAppendTo[{def1,def2,…}] appends declarations to $CompilerEnvironment.

CompilerEnvironmentAppendTo[env,{def1,def2,…}] appends declarations to CompilerEnvironmentObject env.

CompilerEnvironmentObject

CompilerEnvironmentObject represents a collection of definitions that can be included in compilations by FunctionCompile and related functions.

CompilerOptions

CompilerOptions is an option for FunctionCompile and related functions that allows options for the compilation pipeline to be specified.

Complement

Complement[eall,e1,e2,…] gives the elements in eall that are not in any of the ei. 

ComplementedEntityClass

ComplementedEntityClass[classall,class1,…] represents an entity class containing all the entities in classall that are not in any of the classi.

CompleteGraph

CompleteGraph[n] gives the complete graph with n vertices Kn.

CompleteGraph[{n1,n2,…,nk}] gives the complete k-partite graph with n1+n2+⋯+nk vertices Kn1,n2,…,nk.

CompleteGraphQ

CompleteGraphQ[g] yields True if the graph g is a complete graph, and False otherwise.

CompleteGraphQ[g,vlist] yields True if the subgraph induced by vlist is a complete graph, and False otherwise.

CompleteIntegral

CompleteIntegral[pde,u,{x1,…,xn}] gives a complete integral u for the first-order partial differential equation pde, with independent variables {x1,…,xn}. 

CompleteKaryTree

CompleteKaryTree[n] gives the complete binary tree with n levels.

CompleteKaryTree[n,k] gives the complete k-ary tree with n levels.

Complex

Complex is the head used for complex numbers. 

ComplexArrayPlot

ComplexArrayPlot[array] generates a plot in which complex values zij in an array array are shown in a discrete array of squares with Arg[zij] indicated by color and Abs[zij] by shading.

ComplexContourPlot

ComplexContourPlot[f,{z,zmin,zmax}] generates a filled contour plot of f as a function of z. 

ComplexContourPlot[{f1,f2,…},{z,zmin,zmax}] generates contour lines for f1, f2, …. 

ComplexContourPlot[f==g,{z,zmin,zmax}] plots contour lines for which f=g.

ComplexContourPlot[{f1==g1,f2==g2,…},{z,zmin,zmax}] plots contour lines for each of f1g1, f2=g2, …. 

Complexes

Complexes represents the domain of complex numbers, as in x∈Complexes. 

ComplexExpand

ComplexExpand[expr] expands expr assuming that all variables are real. 

ComplexExpand[expr,{x1,x2,…}] expands expr assuming that variables matching any of the xi are complex. 

ComplexInfinity

ComplexInfinity represents a quantity with infinite magnitude, but undetermined complex phase. 

ComplexityFunction

ComplexityFunction is an option for Simplify and other functions which gives a function to rank the complexity of different forms of an expression. 

ComplexListPlot

ComplexListPlot[{z1,z2,…}] plots complex numbers z1, z2, … as points in the complex plane.

ComplexListPlot[{data1,data2,…}] plots data from all datai.

ComplexListPlot[{…,w[datai,…],…}] plots datai with features defined by the symbolic wrapper w.

ComplexPlot

ComplexPlot[f,{z,zmin,zmax}] generates a plot of Arg[f] over the complex rectangle with corners zmin and zmax.

ComplexPlot3D

ComplexPlot3D[f,{z,zmin,zmax}] generates a 3D plot of Abs[f] colored by Arg[f] over the complex rectangle with corners zmin and zmax.

ComplexRegionPlot

ComplexRegionPlot[pred,{z,zmin,zmax}] makes a plot showing the region in the complex plane for which pred is True.

ComplexRegionPlot[{pred1,pred2,…},{z,zmin,zmax}] plots regions given by the multiple predicates predi.

ComplexStreamPlot

ComplexStreamPlot[f,{z,zmin,zmax}] generates a streamline plot of the vector field {Re[f],Im[f]} over the complex rectangle with corners zmin and zmax.

ComplexVectorPlot

ComplexVectorPlot[f,{z,zmin,zmax}] generates a vector plot of the vector field {Re[f],Im[f]} over the complex rectangle with corners zmin and zmax.

ComplexVectorPlot[{f1,f2,…},{z,zmin,zmax}] plots several vector fields.

ComponentMeasurements

ComponentMeasurements[{image,lmat},"prop"] computes the property "prop" for components of image indicated by the label matrix lmat.

ComponentMeasurements[image,"prop"] computes the property "prop" for connected components of image. 

ComponentMeasurements[…,"prop",crit] only returns measurements for components that satisfy the criterion crit.

ComponentMeasurements[…,"prop",crit,format] formats the result according to the output specification format.

ComposeList

ComposeList[{f1,f2,…},x] generates a list of the form {x,f1[x],f2[f1[x]],…}. 

ComposeSeries

ComposeSeries[series1,series2,…] composes several power series. 

CompositeQ

CompositeQ[n] yields True if n is a composite number, and yields False otherwise. 

Composition

Composition[f1,f2,f3,…] represents a composition of the functions f1, f2, f3, ….

CompoundElement

CompoundElement[{spec1,spec2,…}] represents a form or interpreter specification for a list of fields or inputs that gives a list of results.

CompoundElement[<|key1->spec1,key2->spec2,…|>] represents a form or interpreter specification that gives an association of results.

CompoundExpression

expr1;expr2;… evaluates the expri in turn, giving the last one as the result. 

CompoundPoissonDistribution

CompoundPoissonDistribution[λ,dist] represents a compound Poisson distribution with rate parameter λ and jump size distribution dist.

CompoundPoissonProcess

CompoundPoissonProcess[λ,jdist] represents a compound Poisson process with rate parameter λ and jump size distribution jdist.

CompoundRenewalProcess

CompoundRenewalProcess[rdist,jdist] represents a compound renewal process with renewal-time distribution rdist and jump size distribution jdist.

Compress

Compress[expr] gives a compressed representation of expr as a string. 

CompressionLevel

CompressionLevel is an option for Export and CreateArchive that specifies the amount of compression to use when compressing data.

ComputeUncertainty

ComputeUncertainty is an option for ClassifierMeasurements, LearnedDistribution and other functions to specify if numeric results should be returned along with their uncertainty.

ConcaveHullMesh

ConcaveHullMesh[{p1,p2,…}] gives the concave hull mesh from the points p1,p2,….

ConcaveHullMesh[{p1,p2,…},α] gives the concave hull mesh of the specified parameter α.

ConcaveHullMesh[{p1,p2,…},α,d] gives the concave hull mesh of cells of dimension d.

Condition

patt/;test is a pattern which matches only if the evaluation of test yields True. 

lhs:>rhs/;test represents a rule which applies only if the evaluation of test yields True. 

lhs:=rhs/;test is a definition to be used only if test yields True. 

ConditionalExpression

ConditionalExpression[expr,cond] is a symbolic construct that represents the expression expr when the condition cond is True.

Conditioned

Conditioned[expr,cond] or exprcond represents expr conditioned by the predicate cond.

Cone

Cone[{{x1,y1,z1},{x2,y2,z2}},r] represents a cone with a base of radius r centered at (x1,y1,z1) and a tip at (x2,y2,z2). 

Cone[{{x1,y1,z1},{x2,y2,z2}}] represents a cone with a base of radius 1.

ConfidenceLevel

ConfidenceLevel is an option for LinearModelFit and other fitting functions that specifies the level to use in various confidence and prediction intervals and bands.

ConfidenceRange

ConfidenceRange is an option for SurvivalModelFit and other functions that specifies the range over which simultaneous confidence intervals and bands are computed.

ConfidenceTransform

ConfidenceTransform is an option for functions such as SurvivalModelFit that specifies the transformation used for confidence intervals and bands.

ConfigurationPath

ConfigurationPath is a global option that specifies which directories are searched for systemwide configuration information.

Confirm

Confirm[expr] confirms that expr is not considered a failure, otherwise throwing an error to the nearest surrounding Enclose. 

Confirm[expr,info] evaluates info and includes its value in the thrown error if expr is not confirmed.

Confirm[expr,info,tag] uses the specified tag for any thrown errors.

ConfirmAssert

ConfirmAssert[test] confirms that test is True, otherwise throwing an error to the nearest surrounding Enclose.

ConfirmAssert[test,info] evaluates info and includes its value in the thrown error if test is not True.

ConfirmAssert[test,info,tag] uses the specified tag for any thrown errors.

ConfirmBy

ConfirmBy[expr,f] confirms that f[expr] returns True, otherwise throwing an error to the nearest surrounding Enclose.

ConfirmBy[expr,f,info] evaluates info and includes its value in the thrown error if expr is not confirmed.

ConfirmBy[expr,f,info,tag] uses the specified tag for any thrown errors.

ConfirmMatch

ConfirmMatch[expr,form] confirms that expr matches the pattern form, otherwise throwing an error to the nearest surrounding Enclose.

ConfirmMatch[expr,form,info] evaluates info and includes its value in the thrown error if expr is not confirmed.

ConfirmMatch[expr,form,info,tag] uses the specified tag for any thrown errors.

ConfirmQuiet

ConfirmQuiet[expr] confirms that no messages are generated during the evaluation of expr, otherwise quieting them and throwing an error to the nearest surrounding Enclose.

ConfirmQuiet[expr,s::t] tests only for the specified message.

ConfirmQuiet[expr,{s1::t1,s2::t2,…}] tests only for the specified list of messages.

ConfirmQuiet[expr,"group"] tests only for messages in the named message group.

ConfirmQuiet[expr,mspec,info] evaluates info and includes its value in the thrown error if expr is not confirmed.

ConfirmQuiet[expr,mspec,info,tag] uses the specified tag for any thrown errors.

ConformationMethod

ConformationMethod is an option for VideoJoin and others that specifies how to conform frames of different videos.

ConformAudio

ConformAudio[{audio1,audio2,…}] returns a list of audio objects where all audioi are made to have conforming properties, including duration, data type, and number of channels.

ConformAudio[{audio1,audio2,…},spec] returns all audio objects of the specified spec.

ConformImages

ConformImages[{image1,image2,…}] returns a list of images where all imagei are made to have conforming properties, including dimensions, data type, color space, and interleaving.

ConformImages[{image1,image2,…},spec] returns all images of the specified spec.

ConformImages[{image1,image2,…},spec,fitting] resizes images using the specified fitting method.

Congruent

Congruent[x,y,…] displays as x≡y≡….

ConicGradientFilling

ConicGradientFilling[{col1,col2,…,coln}] is a two-dimensional graphics directive specifying that faces of polygons and other filled graphics objects are to be drawn using a progressive transition between colors coli along a circle.

ConicGradientFilling[{θ1,θ2,…,θn}->{col1,col2,…,coln}] uses the colors coli at angles θi.

ConicGradientFilling[{θ1,θ2,…,θn}->{col1,col2,…,coln},{x,y}] rotates from the center point {x,y}.

ConicHullRegion

ConicHullRegion[{p1,…,pm+1}] represents the m-dimensional affine hull region passing through points pi. 

ConicHullRegion[p,{v1,…,vm}] represents the m-dimensional affine hull region passing through the point p and parallel to vi. 

ConicHullRegion[{p1,…,pm+1},{w1,…,wn}] represents the m-dimensional affine hull plus the conic hull generated by the vectors wj.

ConicHullRegion[p,{v1,…,vm},{w1,…,wn}] represents the m-dimensional affine hull plus the conic hull generated by the vectors wj.

ConicOptimization

ConicOptimization[f,cons,vars] finds values of variables vars that minimize the linear objective f subject to conic constraints cons.

ConicOptimization[…,"prop"] specifies what solution property "prop" should be returned.

Conjugate

Conjugate[z] or z gives the complex conjugate of the complex number z. 

ConjugateTranspose

ConjugateTranspose[m] or m gives the conjugate transpose of m. 

Conjunction

Conjunction[expr,{a1,a2,…}] gives the conjunction of expr over all choices of the Boolean variables ai.

Connect

Connect is a setting for the LinkMode option of LinkOpen.  LinkMode->Connect causes a link to be created that will connect to a link listening on a named port.

ConnectedComponents

ConnectedComponents[g] gives the connected components of the graph g.

ConnectedComponents[g,{v1,v2,…}] gives the connected components that include at least one of the vertices v1, v2, … .

ConnectedComponents[g,patt] gives the connected components that include a vertex that matches the pattern patt.

ConnectedComponents[{v->w,…},…] uses rules v->w to specify the graph g.

ConnectedGraphComponents

ConnectedGraphComponents[g] gives the connected components of the graph g.

ConnectedGraphComponents[g,{v1,v2,…}] gives the connected components that include at least one of the vertices v1, v2, … .

ConnectedGraphComponents[g,patt] gives the connected components that include a vertex that matches the pattern patt.

ConnectedGraphComponents[{v->w,…},…] uses rules v->w to specify the graph g.

ConnectedGraphQ

ConnectedGraphQ[g] yields True if the graph g is connected, and False otherwise.

ConnectedMeshComponents

ConnectedMeshComponents[mr] gives a list {c1,c2,…} of disjoint path connected meshed regions.

ConnectedMoleculeQ

ConnectedMoleculeQ[mol] returns True if the atoms in mol form are connected by bonds, and False otherwise.

ConnectionSettings

ConnectionSettings is an option for URLRead and related functions to specify advanced connection settings.

ConnectLibraryCallbackFunction

ConnectLibraryCallbackFunction[mname,cf] connects a CompiledFunction cf with the library callback manager with name mname.

ConnesWindow

ConnesWindow[x] represents a Connes window function of x.

ConnesWindow[x,α] uses the parameter α.

ConservativeConvectionPDETerm

ConservativeConvectionPDETerm[vars,α] represents a conservative convection term ∇{x1,…,xn}·(-α u) with conservative convection coefficient α and model variables vars.

ConservativeConvectionPDETerm[vars,α,pars] uses model parameters pars.

Constant

Constant is an attribute that indicates zero derivative of a symbol with respect to all parameters. 

ConstantArray

ConstantArray[c,n] generates a list of n copies of the element c.

ConstantArray[c,{n1,n2,…}] generates an n1n2… array of nested lists containing copies of the element c.

ConstantArrayLayer

ConstantArrayLayer[] represents a layer that has no input and produces as output a constant array.

ConstantArrayLayer[opts] includes options for initial value of the array or output size.

ConstantImage

ConstantImage[val,size] gives an image of the specified size with constant pixel values of val.

ConstantImage[val,size,"type"] gives an image converted to the specified type.

ConstantPlusLayer

ConstantPlusLayer[] represents a layer that adds a learnable bias to its input.

ConstantPlusLayer[opts] includes options for initial bias and other parameters. 

ConstantRegionQ

ConstantRegionQ[reg] gives True if the reg is a constant region and False otherwise.

Constants

Constants is an option for Dt which gives a list of objects to be taken as constants. 

ConstantTimesLayer

ConstantTimesLayer[] represents a layer that multiplies its input by a learnable scaling array.

ConstantTimesLayer[opts] includes options for initial scaling and other parameters. 

ConstellationData

ConstellationData[entity,property] gives the value of the specified property for the constellation entity.

ConstellationData[{entity1,entity2,…},property] gives a list of property values for the specified constellation entities.

ConstellationData[entity,property,annotation] gives the specified annotation associated with the given property.

Construct

Construct[f,x] gives f[x].

Construct[f,x1,…,xn] gives f[x1,…,xn].

Containing

Containing["outer","inner"] represents an object of type outer containing objects of type inner.

ContainsAll

ContainsAll[list1,list2] yields True if list1 contains all of the elements of list2.

ContainsAll[list2] is an operator form that yields True when the object to which it is applied contains all of the elements of list2.

ContainsAny

ContainsAny[list1,list2] yields True if list1 contains any of the elements of list2.

ContainsAny[list2] is an operator form that yields True when the object to which it is applied contains any of the elements in list2.

ContainsExactly

ContainsExactly[list1,list2] yields True if list1 contains exactly the same elements as list2.

ContainsExactly[list2] is an operator form that yields True when the object to which it is applied contains exactly the same elements as list2.

ContainsNone

ContainsNone[list1,list2] yields True if list1 contains none of the elements in list2.

ContainsNone[list2] is an operator form that yields True when the object to which it is applied contains none of the elements of list2.

ContainsOnly

ContainsOnly[list1,list2] yields True if list1 contains only elements that appear in list2.

ContainsOnly[list2] is an operator form that yields True when the object to which it is applied contains only elements that appear in list2.

ContentDetectorFunction

ContentDetectorFunction[…] represents a function generated by TrainImageContentDetector or TrainTextContentDetector that localizes and classifies contents in a piece of text or an image.

ContentFieldOptions

ContentFieldOptions is an option for CreateSearchIndex and related functions that allows options to be specified for handling different fields in content that is being indexed.

ContentLocationFunction

ContentLocationFunction is an option to CreateSearchIndex and related functions that specifies how to determine locations to be used for hyperlinks and related constructs in the resulting index.

ContentObject

ContentObject["string"] gives a content object whose content is string.

ContentObject[File[…]] gives a content object whose content is stored in the specified file.

ContentObject[<|name1->val1,name2->val2,…|>] gives a content object with a sequence of fields with names namei and values vali.

ContentPadding

ContentPadding is an option for objects that can be displayed with frames that specifies whether the vertical margins should shrink wrap tightly around the contents.

ContentSelectable

ContentSelectable is an option to constructs such as Inset, Graphics, and GraphicsGroup that specifies whether and how content within them should be selectable. 

ContentSize

ContentSize is an option for Manipulate and other functions that specifies the size of the content area to use.

Context

Context[] gives the current context. 

Context[symbol] gives the context in which a symbol appears. 

Context["symbol"] gives the context in which the symbol named "symbol" appears if it exists.

Contexts

Contexts[] gives a list of all contexts. 

Contexts["string"] gives a list of the contexts that match the string. 

ContextToFileName

ContextToFileName["context"] gives the string specifying the file name that is by convention associated with a particular context.

Continue

Continue[] goes to the next iteration of the nearest enclosing Do, For, Until or While in a procedural program. 

ContinuedFraction

ContinuedFraction[x,n] generates a list of the first n terms in the continued fraction representation of x. 

ContinuedFraction[x] generates a list of all terms that can be obtained given the precision of x. 

ContinuedFractionK

ContinuedFractionK[f,g,{i,imin,imax}] represents the continued fraction Κi=iminimaxf/g.

ContinuedFractionK[g,{i,imin,imax}] represents the continued fraction Κi=iminimax1/g.

ContinuousAction

ContinuousAction is an option for Manipulate, Slider, and related functions that specifies whether action should be taken continuously while controls are being moved.

ContinuousMarkovProcess

ContinuousMarkovProcess[i0,q] represents a continuous-time finite-state Markov process with transition rate matrix q and initial state i0.

ContinuousMarkovProcess[p0,q] represents a Markov process with initial state probability vector p0.

ContinuousMarkovProcess[…,m,μ] represents a Markov process with transition matrix m and transition rates μ.

ContinuousMarkovProcess[…,g] represents a Markov process transition rate matrix from the graph g. 

ContinuousTask

ContinuousTask[expr] represents a task in which expr is continuously reevaluated.

ContinuousTask[expr,end] represents a task in which expr is continuously reevaluated until the time specified by end.

ContinuousTask[expr,tspan] represents a task in which expr is continuously reevaluated over the time span tspan.

ContinuousTimeModelQ

ContinuousTimeModelQ[lsys] gives True if lsys is a continuous-time systems model, and False otherwise.

ContinuousWaveletData

ContinuousWaveletData[{{oct1,voc1}->coef1,…},wave] yields a continuous wavelet data object with wavelet coefficients coefi corresponding to octave and voice {octi,voci} and wavelet wave.

ContinuousWaveletTransform

ContinuousWaveletTransform[{x1,x2,…}] gives the continuous wavelet transform of a list of values xi.

ContinuousWaveletTransform[data,wave] gives the continuous wavelet transform using the wavelet wave.

ContinuousWaveletTransform[data,wave,{noct,nvoc}] gives the continuous wavelet transform using noct octaves with nvoc voices per octave.

ContinuousWaveletTransform[sound,…] gives the continuous wavelet transform of sampled sound.

ContourDetect

ContourDetect[image] gives a binary image in which white pixels correspond to the zeros and zero crossings in image.

ContourDetect[image,delta] treats values in image that are smaller in absolute value than delta as zero.

ContourDetect[array,…] gives a binary sparse array in which 1 corresponds to zeros and zero crossings in array. 

ContourGraphics

ContourGraphics[array] is a representation of a contour plot. 

ContourLabels

ContourLabels is an option for contour plots that specifies how to label contours. 

ContourLines

ContourLines is an option for contour plots that specifies whether to draw explicit contour lines. 

ContourPlot

ContourPlot[f,{x,xmin,xmax},{y,ymin,ymax}] generates a contour plot of f as a function of x and y. 

ContourPlot[f==g,{x,xmin,xmax},{y,ymin,ymax}] plots contour lines for which f=g. 

ContourPlot[{f1==g1,f2==g2,…},{x,xmin,xmax},{y,ymin,ymax}] plots several contour lines. 

ContourPlot[…,{x,y}∈reg] takes the variables {x,y} to be in the geometric region reg. 

ContourPlot3D

ContourPlot3D[f,{x,xmin,xmax},{y,ymin,ymax},{z,zmin,zmax}] produces a three-dimensional contour plot of f as a function of x, y, and z. 

ContourPlot3D[f==g,{x,xmin,xmax},{y,ymin,ymax},{z,zmin,zmax}] plots the contour surface for which f=g. 

ContourPlot3D[…,{x,y,z}∈reg] takes the variables {x,y,z} to be in the geometric region reg. 

Contours

Contours is an option for contour plots that specifies the contours to draw. 

ContourShading

ContourShading is an option for contour plots that specifies how the regions between contour lines should be shaded. 

ContourStyle

ContourStyle is an option for contour plots that specifies the style in which contour lines or surfaces should be drawn. 

ContraharmonicMean

ContraharmonicMean[list] gives the contraharmonic mean of the values in list.

ContraharmonicMean[list,p] gives the order p Lehmer contraharmonic mean.

ContrastiveLossLayer

ContrastiveLossLayer[] represents a loss layer that computes a loss based on a distance metric and a target that specifies whether the distance should be minimized or maximized.

ContrastiveLossLayer[margin] specifies a distance above which the loss is zero for True targets.

Control

Control[{u,dom}] represents an interactive control for the variable u in the domain dom, with the type of control chosen to be appropriate for the domain specified.

Control[{{u,uinit},dom}] represents a control with initial value uinit.

ControlActive

ControlActive[act,norm] evaluates to act if a control that affects act is actively being used, and to norm otherwise.

ControllabilityGramian

ControllabilityGramian[ssm] gives the controllability Gramian of the state-space model ssm.

ControllabilityMatrix

ControllabilityMatrix[ssm] gives the controllability matrix of the state-space model ssm.

ControllableDecomposition

ControllableDecomposition[sys] yields the controllable subsystem of the state-space model sys.

ControllableDecomposition[sys,{z1,…}] specifies the new state variables zi.

ControllableModelQ

ControllableModelQ[sys] yields True if the state-space model sys is controllable, and False otherwise.

ControllableModelQ[{sys,sub}] yields True if the subsystem sub is controllable.

ConvectionPDETerm

ConvectionPDETerm[vars,β] represents a convection term β·∇{x1,…,xn}u with convection coefficient β and model variables vars.

ConvectionPDETerm[vars,β,pars] uses model parameters pars.

Convergents

Convergents[list] gives a list of the convergents corresponding to the continued fraction terms list.

Convergents[x,n] gives the first n convergents for a number x.

Convergents[x] gives if possible all convergents leading to the number x.

ConversionOptions

ConversionOptions is an option to Import and Export used to pass special options to a particular format.

ConversionRules

ConversionRules is an option for Cell that can be set to a list of rules specifying how the contents of the cell are to be converted to external formats. 

ConvexHullMesh

ConvexHullMesh[{p1,p2,…}] gives a BoundaryMeshRegion representing the convex hull from the points p1, p2, ….

ConvexHullMesh[mreg] gives the convex hull of the mesh region mreg.

ConvexHullRegion

ConvexHullRegion[{p1,p2,…}] gives the convex hull from the points p1, p2, ….

ConvexHullRegion[reg] gives the convex hull of the region reg.

ConvexOptimization

ConvexOptimization[f,cons,vars] finds values of variables vars that minimize the convex objective function f subject to convex constraints cons.

ConvexOptimization[…,"prop"] specifies what solution property "prop" should be returned.

ConvexPolygonQ

ConvexPolygonQ[poly] gives True if the polygon poly is convex, and False otherwise.

ConvexPolyhedronQ

ConvexPolyhedronQ[poly] gives True if the polyhedron poly is convex, and False otherwise.

ConvexRegionQ

ConvexRegionQ[reg] gives True if reg is a convex region and False otherwise. 

ConvolutionLayer

ConvolutionLayer[n,s] represents a trainable convolutional net layer having n output channels and using kernels of size s to compute the convolution.

ConvolutionLayer[n,{s}] represents a layer performing one-dimensional convolutions with kernels of size s.

ConvolutionLayer[n,{h,w}] represents a layer performing two-dimensional convolutions with kernels of size h×w.

ConvolutionLayer[n,{h,w,d}] represents a three-dimensional convolutions with kernels of size h×w×d.

ConvolutionLayer[n,kernel,opts] includes options for padding and other parameters.

Convolve

Convolve[f,g,x,y] gives the convolution with respect to x of the expressions f and g.

Convolve[f,g,{x1,x2,…},{y1,y2,…}] gives the multidimensional convolution.

ConwayGroupCo1

ConwayGroupCo1[] represents the sporadic simple Conway group Co1.

ConwayGroupCo2

ConwayGroupCo2[] represents the sporadic simple Conway group Co2.

ConwayGroupCo3

ConwayGroupCo3[] represents the sporadic simple Conway group Co3.

CookieFunction

CookieFunction is an option for URLRead, HTTPRequest, and related functions that gives a function to apply to each cookie received when an HTTP response is received.

CoordinateBounds

CoordinateBounds[coords] gives a list {{xmin,xmax},{ymin,ymax},…} of the bounds in each dimension of the region defined by coords. 

CoordinateBounds[coords,δ] pads the ranges of coordinates by ±δ in each dimension.

CoordinateBounds[coords,Scaled[s]] pads by the scaled amount s in each dimension.

CoordinateBounds[coords,{p1,p2,…}] pads by p1, p2, … in successive dimensions.

CoordinateBounds[coords,{{p1min,p1max},{p2min,p2max},…}] gives {{xmin-p1min,xmax+p1max},{ymin-p2min,ymax+p2max},…}

CoordinateBoundsArray

CoordinateBoundsArray[{{xmin,xmax},{ymin,ymax},…}] generates an array of {x,y,…} coordinates with integer steps in each dimension.

CoordinateBoundsArray[{xrange,yrange,…},d] uses step d in each dimension.

CoordinateBoundsArray[{xrange,yrange,…},{dx,dy,…}] uses steps dx, dy, … in successive dimensions.

CoordinateBoundsArray[{xrange,yrange,…},Into[n]] divides into n equal steps in each dimension.

CoordinateBoundsArray[{xrange,yrange,…},steps,offsets] specifies offsets to use for each coordinate point.

CoordinateBoundsArray[{xrange,yrange,…},steps,offsets,k] expands the array by k elements in every direction. 

CoordinateChartData

CoordinateChartData[chart,property] gives the value of the specified property for chart.

CoordinateChartData[chart,property,{x1,x2,…,xn}] gives the value of the specified property for chart evaluated at the point {x1,x2,…,xn}.

CoordinatesToolOptions

CoordinatesToolOptions is an option for Graphics that gives values of options associated with the Get Coordinates tool.

CoordinateTransform

CoordinateTransform[t,pt] performs the coordinate transformation t on the point pt.

CoordinateTransform[t,{pt1,pt2,…}] transforms several points.

CoordinateTransformData

CoordinateTransformData[t,property] gives the value of the specified property for the coordinate transformation t.

CoordinateTransformData[t,property,{x1,x2,…,xn}] gives the value of the property evaluated at the point {x1,x2,…,xn}.

CoplanarPoints

CoplanarPoints[{p1,p2,p3,p4,…,pn}] tests whether the points p1,p2,p3,p4,…,pn are coplanar.

CoprimeQ

CoprimeQ[n1,n2] yields True if n1 and n2 are relatively prime, and yields False otherwise. 

CoprimeQ[n1,n2,…] yields True if all pairs of the ni are relatively prime, and yields False otherwise. 

Coproduct

Coproduct[x,y,…] displays as x∐y∐….

CopulaDistribution

CopulaDistribution[ker,{dist1,dist2,…}] represents a copula distribution with kernel distribution ker and marginal distributions dist1, dist2, … .

CopyDatabin

CopyDatabin[bin] creates a copy of a databin.

CopyDatabin[bin,options] creates a copy with the specified options.

CopyDirectory

CopyDirectory[dir1,dir2] copies the directory dir1 to dir2. 

CopyToClipboard

CopyToClipboard[expr] replaces the contents of the clipboard with expr.

CoreNilpotentDecomposition

CoreNilpotentDecomposition[m] yields the core-nilpotent decomposition of a square matrix m.

CoreNilpotentDecomposition[m,format] returns the core-nilpotent decomposition according to the specified format.

CornerFilter

CornerFilter[image] computes a measure for the presence of a corner for each pixel in image and returns the result as an intensity image.

CornerFilter[image,r] detects corners at a pixel range r.

CornerNeighbors

CornerNeighbors is an option for various array and image processing functions that specifies whether diagonally adjacent corners should be considered neighbors of particular elements. 

CorrelationDistance

CorrelationDistance[u,v] gives the correlation coefficient distance between vectors u and v.

CorrelationFunction

CorrelationFunction[data,hspec] estimates the correlation function at lags hspec from data.

CorrelationFunction[proc,hspec] represents the correlation function at lags hspec for the random process proc. 

CorrelationFunction[proc,s,t] represents the correlation function at times s and t for the random process proc. 

CorrelationTest

CorrelationTest[{{x1,y1},{x2,y2},…}] tests whether the correlation coefficient for a bivariate population is zero.

CorrelationTest[{{x1,y1},{x2,y2},…},ρ0] tests whether the correlation coefficient is ρ0.

CorrelationTest[{{x1,y1},{x2,y2},…},{{u1,v1},{u2,v2},…}] tests whether the correlation coefficients for two populations are equal.

CorrelationTest[…,"property"] returns the value of "property".

Cos

Cos[z] gives the cosine of z. 

Cosh

Cosh[z] gives the hyperbolic cosine of z. 

CoshIntegral

CoshIntegral[z] gives the hyperbolic cosine integral Chi(z).

CosineDistance

CosineDistance[u,v] gives the angular cosine distance between vectors u and v.

CosineWindow

CosineWindow[x] represents a cosine window function of x.

CosineWindow[x,α] uses the exponent α.

CosIntegral

CosIntegral[z] gives the cosine integral function Ci(z). 

Cot

Cot[z] gives the cotangent of z. 

Coth

Coth[z] gives the hyperbolic cotangent of z. 

CoulombF

CoulombF[l,η,r] gives the regular Coulomb wavefunction Fl(η,r).

CoulombG

CoulombG[l,η,r] gives the irregular Coulomb wavefunction Gl(η,r).

CoulombH1

CoulombH1[l,η,r] gives the outgoing irregular Coulomb wavefunction Hl(+)(η,r).

CoulombH2

CoulombH2[l,η,r] gives the incoming irregular Coulomb wavefunction Hl(-)(η,r).

Count

Count[list,pattern] gives the number of elements in list that match pattern. 

Count[expr,pattern,levelspec] gives the total number of subexpressions matching pattern that appear at the levels in expr specified by levelspec. 

Count[pattern] represents an operator form of Count that can be applied to an expression.

CountDistinct

CountDistinct[list] gives the number of distinct elements that appear in list.

CountDistinct[list,test] applies test to pairs of elements to determine whether they should be considered equivalent.

CountDistinctBy

CountDistinctBy[{e1,e2,…},f] gives the number of distinct values of f[ei] that occur.

CountDistinctBy[f] represents an operator form of CountDistinctBy that can be applied to an expression.

CounterAssignments

CounterAssignments is an option for selections that sets the value of a specified counter.

CounterFunction

CounterFunction is an option for counters that specifies the symbols used to display the value of the counter.

CounterIncrements

CounterIncrements is an option for selections that specifies whether the value of a specified counter is incremented by one.

CountRoots

CountRoots[f,x] gives the number of real roots of the univariate function f in x.

CountRoots[f,{x,a,b}] gives the number of roots between a and b. 

CountryData

CountryData["tag",property] gives the value of the specified property for the country, country-like entity, or group of countries specified by "tag".

CountryData["tag",{property,…,dates}] gives time series for certain economic and other properties.

Counts

Counts[list] gives an association whose keys are the distinct elements of list, and whose values give the number of times those elements appear in list.

Counts[list,elems] gives an association whose keys are the distinct elements in elems, and whose values give the number of times those elements appear in list.

CountsBy

CountsBy[{e1,e2,…},f] gives an association whose keys are the distinct values of the f[ei], and whose values give the number of times these f[ei] values appear.

CountsBy[f] represents an operator form of CountsBy that can be applied to an expression.

CovarianceEstimatorFunction

CovarianceEstimatorFunction is an option for generalized linear model fitting functions that specifies the estimator for the parameter covariance matrix.

CovarianceFunction

CovarianceFunction[data,hspec] estimates the covariance function at lags hspec from data.

CovarianceFunction[proc,hspec] represents the covariance function at lags hspec for the random process proc. 

CovarianceFunction[proc,s,t] represents the covariance function at times s and t for the random process proc. 

CoxianDistribution

CoxianDistribution[{α1,…,αm-1},{λ1,…,λm}] represent an m-phase Coxian distribution with phase probabilities αi and rates λi.

CoxIngersollRossProcess

CoxIngersollRossProcess[μ,σ,θ,x0] represents a Cox–Ingersoll–Ross process with long‐term mean μ, volatility σ, speed of adjustment θ, and initial condition x0.

CoxModel

CoxModel[…] represents the symbolic proportional hazards model obtained from CoxModelFit.

CoxModelFit

CoxModelFit[{e1,…,en}] constructs a model of the baseline hazard h0(t) for events times ei.

CoxModelFit[{{{ξ11,…,ξ1p},…,{ξn 1,…,ξnp}},{e1,…,en}},{f1,…,fm},{x1,…,xp}] constructs a Cox model of the form h0(t) exp(β1 f1+…+βm fm), where the fi depend on the xk.

CramerVonMisesTest

CramerVonMisesTest[data] tests whether data is normally distributed using the Cramér–von Mises test.

CramerVonMisesTest[data,dist] tests whether data is distributed according to dist using the Cramér–von Mises test.

CramerVonMisesTest[data,dist,"property"] returns the value of "property".

CreateArchive

CreateArchive[source] creates a compressed archive in the current directory from source.

CreateArchive[source,path] creates a compressed archive in the directory or file specified by path.

CreateChannel

CreateChannel[] creates a new channel for channel communication, with a generated name.

CreateChannel["path"] creates a channel with the specified path relative to the home area of the currently authenticated user.

CreateChannel[object] creates a channel based on the given ChannelObject specification.

CreateCompilerEnvironment

CreateCompilerEnvironment[] creates a compiler environment that can be used in FunctionCompile and related functions.

CreateDatabin

CreateDatabin[] creates a databin in the Wolfram Data Drop and returns the corresponding Databin object.

CreateDatabin[options] creates a databin with the specified options.

CreateDataStructure

CreateDataStructure["type",arg1,arg2,…] creates a data structure with the specified type.

CreateDirectory

CreateDirectory["dir"] creates a directory with name dir. 

CreateDirectory[] creates a directory in the default area for temporary directories on your computer system.

CreateFile

CreateFile["file"] creates a file with name file. 

CreateFile[] creates a file in the default area for temporary files on your computer system.

CreateIntermediateDirectories

CreateIntermediateDirectories is an option for CreateDirectory and related functions that specifies whether to create intermediate directories in a directory path specified.

CreateLicenseEntitlement

CreateLicenseEntitlement[settings] creates an on-demand license entitlement using settings.

CreateLicenseEntitlement[] creates an on-demand license entitlement using the default settings.

CreateManagedLibraryExpression

CreateManagedLibraryExpression[mname,f] creates a managed library expression by applying f to a positive integer ID associated with a registered manager with name mname.

CreatePacletArchive

CreatePacletArchive[source] creates a paclet archive file from source.

CreatePacletArchive[source,destdir] creates a paclet archive file from source and places it in destdir.

CreatePermissionsGroup

CreatePermissionsGroup["name"] creates a permissions group with the specified name.

CreatePermissionsGroup["name",{user1,user2,…}] creates a permissions group consisting of the specified initial users.

CreateScheduledTask

CreateScheduledTask[expr] creates a local scheduled task that will repeatedly evaluate expr once per second.

CreateScheduledTask[expr,time] creates a task that will repeatedly evaluate expr every time seconds.

CreateScheduledTask[expr,{time}] creates a task that will evaluate expr once after time seconds.

CreateScheduledTask[expr,{time,count}] creates a task that will try evaluating expr once every time seconds up to count times total.

CreateScheduledTask[expr,timespec,start] creates a task that will evaluate expr according to timespec starting at start time.

CreateSearchIndex

CreateSearchIndex[dir] creates a search index from all files in the directory dir and its subdirectories.

CreateSearchIndex[{source1,source2,…}] creates a search index from all sources sourcei.

CreateSearchIndex[sources,"name"] gives the search index the specified name.

CreateSearchIndex[] creates an empty search index, which can be added to with AddToSearchIndex.

CreateTemporary

CreateTemporary[] creates a temporary file with a unique name in the default temporary directory and returns the name of the file.

CreateUUID

CreateUUID[] creates a random, universally unique UUID string.

CreateUUID["base"] appends a UUID string to the specified base string.

CriterionFunction

CriterionFunction is an option in functions such as ClusterClassify that specifies the criterion to use to select a method.

CriticalityFailureImportance

CriticalityFailureImportance[rdist,t] gives the criticality failure importances for all components in the ReliabilityDistribution rdist at time t.

CriticalityFailureImportance[fdist,t] gives the criticality failure importances for all components in the FailureDistribution fdist at time t.

CriticalitySuccessImportance

CriticalitySuccessImportance[rdist,t] gives the criticality success importances for all components in the ReliabilityDistribution rdist at time t.

CriticalitySuccessImportance[fdist,t] gives the criticality success importances for all components in the FailureDistribution fdist at time t.

CriticalSection

CriticalSection[var,expr] acquires the lock var for parallel computation, evaluates expr, then releases the lock var.

CriticalSection[{var1,var2,…},expr] locks all variables vari simultaneously.

Cross

Cross[a,b] gives the vector cross product of a and b. 

CrossEntropyLossLayer

CrossEntropyLossLayer["Index"] represents a net layer that computes the cross-entropy loss by comparing input class probability vectors with indices representing the target class.

CrossEntropyLossLayer["Probabilities"] represents a net layer that computes the cross-entropy loss by comparing input class probability vectors with target class probability vectors.

CrossEntropyLossLayer["Binary"] represents a net layer that computes the binary cross-entropy loss by comparing input probability scalars with target probability scalars, where each probability represents a binary choice.

CrossingCount

CrossingCount[contour,p] gives a count of the number of times a ray starting from the point p crosses the closed curve contour.

CrossingDetect

CrossingDetect[image] gives a binary image in which white pixels correspond to the zero crossings in image.

CrossingDetect[image,delta] treats values in image that are smaller in absolute value than delta as zero.

CrossingDetect[array,…] gives a binary sparse array in which 1 corresponds to zero crossings in array. 

CrossingPolygon

CrossingPolygon[{p1,p2,…,pn}] gives a Polygon representing all points for which a ray from the point in any direction in the plane crosses the line segments {p1,p2},…,{pn-1,pn},{pn,p1} an odd number of times.

CrossingPolygon[{{p11,p12,…},{p21,p22,…},…}] gives a Polygon from the line segments {p11,p12},…,{p21,p22},….

Csc

Csc[z] gives the cosecant of z. 

Csch

Csch[z] gives the hyperbolic cosecant of z. 

CSGRegion

CSGRegion[{reg1,reg2,…}] represents the solid region corresponding to the union of solid regions reg1,reg2,….

CSGRegion["op",{reg1,reg2,…}] represents the solid region corresponding to the Boolean combination "op" of regions reg1,reg2,….

CSGRegion["op",{…,wi[regi],…}] represents the solid region defined by regions regi transformed by a geometric transformation wi.

CSGRegionQ

CSGRegionQ[reg] yields True if the region reg is a valid CSGRegion object and False otherwise.

CSGRegionTree

CSGRegionTree[reg] gives the tree expression representing the CSG region reg.

CTCLossLayer

CTCLossLayer[] represents a net layer that computes the connectionist temporal classification loss by comparing a sequence of class probability vectors with a sequence of indices representing the target classes.

Cube

Cube[] represents a regular cube centered at the origin with unit edge length.

Cube[l] represents a cube with edge length l.

Cube[{θ,ϕ},…] represents a cube rotated by an angle θ with respect to the z axis and angle ϕ with respect to the y axis.

Cube[{x,y,z},…] represents a cube centered at {x,y,z}.

CubeRoot

CubeRoot[x] gives the real-valued cube root of x.

Cubics

Cubics is an option for functions that involve solving algebraic equations, that specifies whether explicit forms for solutions to cubic equations should be given.

Cuboid

Cuboid[pmin] represents a unit hypercube with its lower corner at pmin.

Cuboid[pmin,pmax] represents an axis-aligned filled cuboid with lower corner pmin and upper corner pmax.

Cumulant

Cumulant[data,r] gives the rth cumulant κr of data.

Cumulant[data,{r1,…,rm} ] gives the multivariate cumulant of order {r1,…,rm} κr1, …, rm of data.

Cumulant[dist,r] gives the rth cumulant of the distribution dist.

Cumulant[r] represents the rth formal cumulant. 

CumulantGeneratingFunction

CumulantGeneratingFunction[dist,t] gives the cumulant-generating function for the distribution dist as a function of the variable t. 

CumulantGeneratingFunction[dist,{t1,t2,…}] gives the cumulant-generating function for the multivariate distribution dist as a function of the variables t1, t2, … . 

Cup

Cup[x,y,…] displays as x⌣y⌣….

CupCap

CupCap[x,y,…] displays as x≍y≍….

Curl

Curl[{f1,f2},{x1,x2}] gives the curl ∂f2/∂x1-∂f1/∂x2.

Curl[{f1,f2,f3},{x1,x2,x3}] gives the curl (∂f3/∂x2-∂f2/∂x3,∂f1/∂x3-∂f3/∂x1,∂f2/∂x1-∂f1/∂x2).

Curl[f,{x1,…,xn}] gives the curl of the n×n×…×n array f with respect to the n-dimensional vector {x1,…,xn}.

Curl[f,x,chart] gives the curl in the coordinates chart.

CurrencyConvert

CurrencyConvert[quantity,target] attempts to convert the specified currency quantity to the specified target currency.

CurrencyConvert[quantity,target,date] converts to the target currency for the historical date specification.

CurrentDate

CurrentDate[gran] gives the current date of the specified granularity type gran.

CurrentDate[date,gran] gives the date of the given granularity that includes the specified date.

CurrentDate[] gives the instant corresponding to the current date.

CurrentImage

CurrentImage[] returns the current image captured from a connected camera.

CurrentImage[n] returns n sequential image frames as a list.

Curry

Curry[f,n] represents an operator form of the function f of n arguments so that Curry[f,n][x1]…[xn] is equivalent to f[x1,…,xn].

Curry[f] represents an operator form of the function f of two arguments so that Curry[f][y][x] is equivalent to f[x,y].

Curry[f,{i1,…,in}] represents an operator form of the function f of n arguments so that Curry[f,{i1,…,in}][x1]…[xn] is equivalent to f[xi1,…,xin].

Curry[f,k->{i1,…,in}] represents a k-arguments operator form of the function f of n arguments so that Curry[f,k->{i1,…,in}][x1]…[xk] is equivalent to f[xi1,…,xin], with k≥Max[{i1,…,in}].

CurryApplied

CurryApplied[f,n] represents an operator form of the function f of n arguments so that CurryApplied[f,n][x1]…[xn] is equivalent to f[x1,…,xn].

CurryApplied[n] represents an operator form of CurryApplied that can be applied to a function to represent an operator form with n arguments.

CurryApplied[f,{i1,…,in}] represents an operator form of the function f of n arguments so that CurryApplied[f,{i1,…,in}][x1]…[xn] is equivalent to f[xi1,…,xin].

CurryApplied[f,k->{i1,…,in}] represents an operator form that takes k arguments.

CurvatureFlowFilter

CurvatureFlowFilter[image] applies a mean curvature flow filter to image.

CurvatureFlowFilter[image,t] specifies the amount of curvature flow time t to be applied.

CurvatureFlowFilter[image,t,k] applies the curvature flow with a modified conductance term parametrized by k.

CurveClosed

CurveClosed is an option for JoinedCurve that specifies whether individual curve components should be closed curves.

Cyan

Cyan represents the color cyan in graphics or style specifications. 

CycleGraph

CycleGraph[n] gives the cycle graph with n vertices Cn.

CycleIndexPolynomial

CycleIndexPolynomial[perm,{x1,…,xn}] constructs the cycle index monomial of the permutation perm in the variables xi.

CycleIndexPolynomial[group,{x1,…,xn}] constructs the cycle index polynomial of group in the variables xi.

Cycles

Cycles[{cyc1,cyc2,…}] represents a permutation with disjoint cycles cyci.

CyclicGroup

CyclicGroup[n] represents the cyclic group of degree n.

Cyclotomic

Cyclotomic[n,x] gives the nth cyclotomic polynomial in x. 

Cylinder

Cylinder[{{x1,y1,z1},{x2,y2,z2}},r] represents a cylinder of radius r around the line from (x1,y1,z1) to (x2,y2,z2). 

Cylinder[{{x1,y1,z1},{x2,y2,z2}}] represents a cylinder of radius 1. 

CylindricalDecomposition

CylindricalDecomposition[expr,{x1,x2,…}] finds a decomposition of the region represented by the statement expr into cylindrical parts whose directions correspond to the successive xi. 

CylindricalDecomposition[expr,{x1,x2,…},op] finds a decomposition of the result of applying the topological operation op to the region represented by the statement expr.

CylindricalDecomposition[expr,{x1,x2,…},"Function"] represents the result as CylindricalDecompositionFunction[…][x1,x2,…] that can be efficiently used in further computation.

CylindricalDecompositionFunction

CylindricalDecompositionFunction[data][x1,x2,…] represents a cylindrical algebraic formula in x1,x2,….

D

D[f,x] gives the partial derivative ∂f/∂x. 

D[f,{x,n}] gives the multiple derivative ∂nf/∂xn.

D[f,x,y,…] gives the partial derivative ⋯ (∂/∂y)(∂/∂x) f.

D[f,{x,n},{y,m},…] gives the multiple partial derivative ⋯ (∂m/∂ym)(∂n/∂xn) f.

D[f,{{x1,x2,…}}] for a scalar f gives the vector derivative (∂f/∂x1,∂f/∂x2,…). 

D[f,{array}] gives an array derivative.

DagumDistribution

DagumDistribution[p,a,b] represents a Dagum distribution with shape parameters p and a and scale parameter b.

DamData

DamData[entity,property] gives the value of the specified property for the dam entity.

DamData[{entity1,entity2,…},property] gives a list of property values for the specified dam entities.

DamData[entity,property,annotation] gives the specified annotation associated with the given property.

DamerauLevenshteinDistance

DamerauLevenshteinDistance[u,v] gives the Damerau–Levenshtein distance between strings or vectors u and v.

DamerauLevenshteinDistance[u,v] gives the Damerau–Levenshtein distance between strings, vectors or biomolecular sequences u and v.

DampingFactor

DampingFactor is an option for FindRoot, which can be used to control convergence behavior. DampingFactor -> n uses a damping factor of n in Newton's method.

Darker

Darker[color] represents a darker version of the specified color. 

Darker[color,f] represents a version of the specified color darkened by a fraction f. 

Darker[image,…] gives a darker version of an image.

Darker[video,…] gives a version of a video with darker frames.

Dashed

Dashed is a graphics directive specifying that lines that follow should be drawn dashed.

Dashing

Dashing[{r1,r2,…}] is a two-dimensional graphics directive specifying that lines that follow are to be drawn dashed, with successive segments of lengths r1, r2, … (repeated cyclically). The ri are given as a fraction of the total width of the graph. 

Dashing[r] is equivalent to Dashing[{r,r}].

Dashing[{r1,r2,…},offset] offsets the dashes by offset.

Dashing[{r1,r2,…},offset,capform] sets the CapForm for individual dashes to capform.

DatabaseConnect

DatabaseConnect[db] activates a connection to the database db.

DatabaseDisconnect

DatabaseDisconnect[db] deactivates a connection to the database db. 

DatabaseReference

DatabaseReference[File["filename"]] represents a reference to a local file-based SQL database.

DatabaseReference[URL["url"]] represents a reference to a server-based SQL database.

DatabaseReference[assoc] represents a fully specified reference to any SQL database.

Databin

Databin["id"] represents a databin in the Wolfram Data Drop.

Databin["id",n] represents the first n entries in a databin.

Databin["id",-n] represents the most recent n entries in a databin.

Databin["id",{m,n}] represents entries m through n in a databin, with negative numbers counting from the end.

Databin["id",{m,n,s}] represents entries m through n with step s.

Databin["id",time] represents entries going back for the quantity of time specified by time.

Databin["id",date] represents the entries in a databin from the specified date to now.

Databin["id",{date1,date2}] represents the entries in a databin from date1 to date2.

Databin["id",range,{key1,key2,…}] represents only elements with keys keyi within each entry in a databin.

DatabinAdd

DatabinAdd[bin,data] adds the specified data to a databin.

DatabinRemove

DatabinRemove[bin,i] removes the ithentry from a databin.

DatabinRemove[bin,uuid] removes the entry with the specified UUID from a databin.

DatabinRemove[bin,{i,j}] removes the span of entries with indices from i through j.

Databins

Databins[] gives a list of databins associated with the currently connected user.

DatabinSubmit

DatabinSubmit[bin,data] submits the specified data to be added to the databin bin asynchronously.

DatabinUpload

DatabinUpload[bin,{entry1,entry2,…}] bulk uploads all the entries entryi to a databin.

DatabinUpload[bin,EventSeries[…]] bulk uploads all entries in an event series to a databin.

DataDistribution

DataDistribution[ddist,…] represents a probability distribution of type ddist, estimated from a set of data.

DataRange

DataRange is an option for functions such as ListPlot and ListDensityPlot that specifies what range of actual coordinates the data should be assumed to occupy. 

DataReversed

DataReversed is an option for ArrayPlot and related functions that specifies whether data should be plotted in reverse order.

Dataset

Dataset[data] represents a structured dataset based on a hierarchy of lists and associations.

DatasetTheme

DatasetTheme is an option for Dataset that specifies an overall theme for a dataset and its elements. 

DataStructure

DataStructure["type",data] represents a data structure.

DataStructureQ

DataStructureQ[ds] yields True if ds is a valid data structure and False otherwise.

DataStructureQ[ds,type] yields True if ds is a valid data structure of the specified type and False otherwise.

Date

Date[] gives the current local date and time in the form {year,month,day,hour,minute,second}. 

DateBounds

DateBounds[{date1,date2,…}] gives the earliest and latest of the datei.

DateBounds[tseries] gives the first and last dates in the time series tseries.

DateBounds[bin] gives the first and last time stamps in the databin bin.

DateBounds[interval] gives the start and end dates of the date interval interval.

DateBounds[interval,gran] gives the endpoints of interval in the specified granularity gran.

Dated

Dated[obj,year] represents the object obj associated with a particular year.

Dated[obj,date] represents the object obj associated with a date.

Dated[obj,All] represents the object obj for all dates where information is available about it.

DateDifference

DateDifference[date1,date2] gives the number of days from date1 to date2.

DateDifference[date1,date2,"unit"] gives the difference between date1 and date2 in the specified unit.

DateDifference[date1,date2,{"unit1","unit2",…}] gives the difference as a list with elements corresponding to the successive "uniti".

DatedUnit

DatedUnit[unit,date] represents the specified unit at a specific date.

DateFunction

DateFunction is an option for DateListPlot and TemporalData that specifies how dates given as input should be interpreted.

DateHistogram

DateHistogram[{date1,date2,…}] plots a histogram of the dates datei.

DateHistogram[{date1,date2,…},bspec] plots a histogram with bin width specification bspec.

DateHistogram[{date1,date2,…},bspec,hspec] plots a histogram with bin heights computed according to the specification hspec.

DateHistogram[{data1,data2,…}] plots histograms for multiple datasets datai.

DateInterval

DateInterval[{start,end}] represents the continuous interval of time between start and end.

DateInterval[{start,end},gran] represents an interval of dates with calendar granularity gran.

DateInterval[{{start1,end1},{start2,end2},…}] represents the union of intervals start1 to end1, start2 to end2, ….

DateInterval[gdate] gives the date interval from the initial to final instants of the granular date object gdate.

DateList

DateList[] gives the current local date and time in the form {year,month,day,hour,minute,second}. 

DateList[date] gives a date list corresponding to the given date specification.

DateListLogPlot

DateListLogPlot[{{date1,y1},{date2,y2},…}] makes a log plot with values yi at a sequence of dates.

DateListLogPlot[{y1,y2,…},datespec] makes a log plot with dates at equal intervals specified by datespec.

DateListLogPlot[tseries] plots the time series tseries.

DateListLogPlot[{data1,data2,…}] plots data from all the datai.

DateListLogPlot[{…,w[datai],…}] plots datai with features defined by the symbolic wrapper w.

DateListPlot

DateListPlot[{{date1,y1},{date2,y2},…,{daten,yn}}] plots points with values yi at a sequence of dates.

DateListPlot[{y1,y2,…,yn},datespec] plots points with dates at equal intervals specified by datespec.

DateListPlot[tseries] plots the time series tseries.

DateListPlot[{data1,data2,…}] plots data from all the datai.

DateListPlot[{…,w[datai],…}] plots datai with features defined by the symbolic wrapper w.

DateListStepPlot

DateListStepPlot[{{date1,y1},{date2,y2},…}] plots the values yi in steps at a sequence of dates.

DateListStepPlot[{y1,y2,…},datespec] plots the values yi in steps with dates at equal intervals specified by datespec.

DateListStepPlot[tseries] plots the time series tseries.

DateListStepPlot[{data1,data2,…}] plots data from all the datai.

DateListStepPlot[…,step] plots using steps specified by step.

DateListStepPlot[{…,w[datai],…}] plots data datai with features defined by the symbolic wrapper w.

DateObject

DateObject[] gives the current local date.

DateObject[date] gives a date object corresponding to the given date specification.

DateObject[rdate,gran] gives the date object of calendar granularity gran that includes the reference date rdate.

DateObjectQ

DateObjectQ[expr] gives True if expr is a DateObject with valid arguments, and False otherwise.

DateOverlapsQ

DateOverlapsQ[date1,date2] returns True if the calendar dates date1 and date2 overlap, and False otherwise.

DatePattern

DatePattern[{"e1","e2",…}] represents the characters of a date with elements of type "ei" in StringExpression.

DatePattern[{"e1","e2",…},sep] allows separators that match the string expression sep.

DatePlus

DatePlus[date,n] gives the date n days after date.

DatePlus[date,{n,step}] gives the date n calendar steps after date.

DatePlus[date,{{n1,step1},{n2,step2},…}] gives a date offset by ni steps of each specified size. 

DatePlus[n] gives the date n days after the current date.

DatePlus[offset] gives the date with the specified offset from the current date.

DateRange

DateRange[date1,date2] gives all dates in the range from date1 to date2.

DateRange[date1,date2,increment] gives the dates in the range from date1 to date2 that are increment apart.

DateReduction

DateReduction is an option for DateHistogram that specifies the length for cyclic periods of time.

DateScale

DateScale[] represents the canonical mapping of continuous dates and times to a quantitative scale.

DateSelect

DateSelect[list,crit] picks out all dates datei of a list for which crit[datei] is True.

DateSelect[int,crit] returns all dates within the DateInterval int for which crit[datei] is True.

DateSelect[crit] represents an operator form of DateSelect that can be applied to an expression.

DateString

DateString[] gives a string representing the complete current local date and time. 

DateString[date] gives a string corresponding to the given date specification.

DateString[{"elem1","elem2",…}] concatenates the specified elements in the order given.

DateString[date,fmt] gives elements specified by the date format fmt for the date or time specification date.

DateTicksFormat

DateTicksFormat is an option for DateListPlot which specifies how date tick labels should be formatted.

DateValue

DateValue["elem"] gives the specified element of the current date and time.

DateValue[{elem1,elem2,…}] gives a list of the specified elements of the current date and time.

DateValue[date,elem] gives the specified element of the specified date.

DateValue[date,elem,form] gives the result in the specified form.

DateWithinQ

DateWithinQ[date1,date2] returns True if the calendar date date2 is entirely contained within date1, and False otherwise.

DaubechiesWavelet

DaubechiesWavelet[] represents a Daubechies wavelet of order 2. 

DaubechiesWavelet[n] represents a Daubechies wavelet of order n.

DavisDistribution

DavisDistribution[b,n,μ] represents a Davis distribution with scale parameter b, shape parameter n, and location parameter μ.

DawsonF

DawsonF[z] gives the Dawson integral F(z).

DayCount

DayCount[date1,date2] gives the number of days from date1 to date2.

DayCount[date1,date2,daytype] gives the number of days of the specified daytype from date1 to date2.

DayCountConvention

DayCountConvention is an option that specifies the day count convention used by DateDifference.

DayHemisphere

DayHemisphere[] is a two-dimensional GeoGraphics primitive that represents the half of the Earth that is currently in daylight. 

DayHemisphere[datespec] represents the daylight half of the Earth for the specified date.

DaylightQ

DaylightQ[] gives True if it is currently daylight from the user's location.

DaylightQ[datespec] gives True if it is daylight from the user's location on the specified datespec.

DaylightQ[locationspec] gives True if it is currently daylight from the specified locationspec.

DaylightQ[locationspec,datespec] gives True if it is daylight from the specified locationspec on the specified datespec.

DaylightQ[{{location1,date1},{location2,date2},…}] gives True if it is daylight from the specified locations and dates.

DaylightQ[locationspec,datespec,inclusionspec] gives True if it is daylight from the specified locationspec on the specified datespec taking inclusionspec into account.

DayMatchQ

DayMatchQ[date,daytype] returns True if the date matches the daytype specification and returns False otherwise.

DayName

DayName[] gives the current day of the week.

DayName[date] gives the day of the week for the given date.

DayNightTerminator

DayNightTerminator[] is a one-dimensional GeoGraphics primitive that represents the separation line between the halves of the Earth currently in daytime and nighttime.

DayNightTerminator[datespec] represents the separation line between day and night for the specified date.

DayPlus

DayPlus[date,n] gives the date n days away from date.

DayPlus[date,n,daytype] gives the date that is n days of daytype away from date.

DayRange

DayRange[date1,date2] gives the dates in the range from date1 to date2.

DayRange[date1,date2,daytype] gives the dates in the range from date1 to date2 that are of the specified daytype.

DayRound

DayRound[date,daytype] rounds date to the nearest day of daytype, using the next-day rounding convention.

DayRound[date,daytype,rounding] rounds date to the nearest day of daytype, using rounding.

DeBruijnGraph

DeBruijnGraph[m,n] gives the n-dimensional De Bruijn graph with m symbols.

DeBruijnGraph[m,n,type] gives the De Bruijn graph with connectivity given by type.

DeBruijnSequence

DeBruijnSequence[list,n] gives a de Bruijn sequence on the elements in list taken n at a time.

DeBruijnSequence[k,n] gives a de Bruijn sequence on the elements 0,…,k-1.

DeBruijnSequence["string",n] gives a de Bruijn sequence on the characters in "string".

Decapitalize

Decapitalize[string] yields a string in which the first character has been made lowercase.

DecimalForm

DecimalForm[expr] prints with approximate real numbers in expr always given in decimal form, without scientific notation.

DecimalForm[expr,n] prints with approximate real numbers given in decimal form to n-digit precision.

DecimalForm[expr,{n,f}] prints with approximate real numbers having n digits, with f digits to the right of the decimal point.

DeclarePackage

DeclarePackage["context`",{"name1","name2",…}] declares that Needs["context`"] should automatically be executed if a symbol with any of the specified names is ever used. 

Decompose

Decompose[poly,x] decomposes a polynomial, if possible, into a composition of simpler polynomials. 

DeconvolutionLayer

DeconvolutionLayer[n,sz] represents a trainable deconvolutional net layer having n output channels and using kernels of size sz to compute the deconvolution.

DeconvolutionLayer[n,{s}] represents a layer performing one-dimensional deconvolutions with kernels of size s.

DeconvolutionLayer[n,{h,w}] represents a layer performing two-dimensional deconvolutions with kernels of size h×w.

DeconvolutionLayer[n,kernel,opts] includes options for initial kernels and other parameters. 

Decrement

x-- decreases the value of x by 1, returning the old value of x. 

Decrypt

Decrypt["password",enc] attempts to decrypt the encrypted object enc using the specified password.

Decrypt[keyspec,enc] attempts to decrypt using the cryptographic key specification keyspec.

Decrypt[obj] interactively requests a password with which to try to decrypt obj.

DecryptFile

DecryptFile["password",file] generates a decrypted version of a file, using the specified password.

DecryptFile["password",source,target] generates a decrypted version of source, putting the result in target.

DecryptFile[keyspec,source,…] decrypts using the cryptographic key specification keyspec.

DedekindEta

DedekindEta[τ] gives the Dedekind eta modular elliptic function η(τ).

DeepSpaceProbeData

DeepSpaceProbeData[entity,property] gives the value of the specified property for the deep space probe entity.

DeepSpaceProbeData[{entity1,entity2,…},property] gives a list of property values for the specified deep space probe entities.

DeepSpaceProbeData[entity,property,annotation] gives the specified annotation associated with the given property.

DefaultAxesStyle

DefaultAxesStyle is a low-level option for graphics functions that specifies the default style to use in displaying axes and axes-like constructs.

DefaultColor

DefaultColor is an option for graphics functions that specifies the default color to use for lines, points, etc. 

DefaultDuration

DefaultDuration is an option to Animate and related functions that specifies the default total duration of the animation in seconds.

DefaultElement

DefaultElement is an option for Grid and related constructs which specifies what to insert when a new element is interactively created.

DefaultFaceGridsStyle

DefaultFaceGridsStyle is a low-level option for 3D graphics functions that specifies the default style to use in rendering face grids.

DefaultFieldHintStyle

DefaultFieldHintStyle is a low-level option for InputField that specifies the default style to use for displaying the field hint.

DefaultFontProperties

DefaultFontProperties is a global option that allows overriding properties of specified font families.

DefaultFrameStyle

DefaultFrameStyle is a low-level option for graphics and related constructs that specifies the default style to use in displaying their frames.

DefaultFrameTicksStyle

DefaultFrameTicksStyle is a low-level option for 2D graphics functions that specifies the default style to use in rendering frame ticks.

DefaultGridLinesStyle

DefaultGridLinesStyle is a low-level option for 2D graphics functions that specifies the default style to use in rendering grid lines.

DefaultNaturalLanguage

DefaultNaturalLanguage is an option for character selections that specifies the language used when checking the spelling of a word in a human natural language selection.

DefaultOptions

DefaultOptions is a style option that allows default options to be specified for particular formatting and related constructs. 

DefaultPrintPrecision

DefaultPrintPrecision is an option for NumberForm, DecimalForm and related functions that specifies the default number of digits of precision with which to print machine numbers.

DefaultStyleDefinitions

DefaultStyleDefinitions is a global option that specifies the default stylesheet for all new notebooks.

DefaultTicksStyle

DefaultTicksStyle is a low-level option for graphics functions that specifies the default style to use in rendering ticks.

DefaultTooltipStyle

DefaultTooltipStyle is a low-level option for tooltips that specifies the default style to use in displaying their elements.

DefaultValues

DefaultValues[f] gives a list of transformation rules corresponding to default values of f.

DefaultValues["symbol"] gives a list of transformation rules corresponding to all default values defined for the symbol named "symbol" if it exists.

Defer

Defer[expr] yields an object that displays as the unevaluated form of expr, but that is evaluated if it is explicitly given as Wolfram Language input. 

DefineInputStreamMethod

DefineInputStreamMethod["name",{fname1->function1,fname2->function2,… }] defines a custom input stream method with the specified name, allowing the Wolfram Language to call the stream functions fnamei for opening and reading from an input stream.

DefineOutputStreamMethod

DefineOutputStreamMethod["name",{fname1->function1,fname2->function2,… }] defines a custom output stream method with the specified name, allowing the Wolfram Language to call the stream functions for opening and writing to an output stream.

DefineResourceFunction

DefineResourceFunction[f] defines a resource function that can be applied to arguments to give the same result as f[…].

DefineResourceFunction[f,name] uses name as the name of the resource function.

Definition

Definition[symbol] prints as the definitions given for a symbol.

Definition["symbol"] prints as the definitions given for the symbol named "symbol" if it exists.

Definition[patt] prints as the definitions given for the symbols whose names textually match the arbitrary string pattern patt.

Definition[{spec1,spec2,…}] prints as the definitions given for the symbols that are equal to or or whose names match any of the speci.

Degree

Degree gives the number of radians in one degree. It has a numerical value of π/180. 

DegreeCentrality

DegreeCentrality[g] gives a list of vertex degrees for the vertices in the underlying simple graph of g.

DegreeCentrality[g,"In"] gives a list of vertex in-degrees.

DegreeCentrality[g,"Out"] gives a list of vertex out-degrees.

DegreeCentrality[{v->w,…},…] uses rules v->w to specify the graph g.

DegreeGraphDistribution

DegreeGraphDistribution[dlist] represents a degree graph distribution with vertex degree dlist.

DEigensystem

DEigensystem[ℒ[u[x,y,…]],u,{x,y,…}∈Ω,n] gives the n smallest magnitude eigenvalues and eigenfunctions for the linear differential operator ℒ over the region Ω.

DEigensystem[eqns,u,t,{x,y,…}∈Ω,n] gives the eigenvalues and eigenfunctions for solutions u of the time-dependent differential equations eqns.

DEigenvalues

DEigenvalues[ℒ[u[x,y,…],u,{x,y,…}∈Ω,n] gives the n smallest magnitude eigenvalues for the linear differential operator ℒ over the region Ω.

DEigenvalues[eqns,u,t,{x,y,…}∈Ω,n] gives the eigenvalues for solutions u of the time-dependent differential equations eqns.

Del

Del[x] displays as ∇x.

DelaunayMesh

DelaunayMesh[{p1,p2,…}] gives a MeshRegion representing the Delaunay mesh from the points p1, p2, ….

Delayed

Delayed[expr] represents an expression whose evaluation is delayed until its value is externally requested.

Delayed[expr,fmt] specifies that the result from evaluating expr should be given in format fmt.

Delayed[expr,{fmt,rform}] specifies that the result should be given as a response of the form rform.

Delete

Delete[expr,n] deletes the element at position n in expr. If n is negative, the position is counted from the end. 

Delete[expr,{i,j,…}] deletes the part at position {i,j,…}. 

Delete[expr,{{i1,j1,…},{i2,j2,…},…}] deletes parts at several positions. 

Delete[pos] represents an operator form of Delete that can be applied to an expression.

DeleteAnomalies

DeleteAnomalies[{example1,example2,…}] gives a list in which examplei that are considered anomalous have been dropped.

DeleteAnomalies[fun,data] drops anomalies in data using the given AnomalyDetectorFunction[…] or LearnedDistribution[…].

DeleteBorderComponents

DeleteBorderComponents[image] replaces connected components adjacent to the border in a binary image image with background pixels.

DeleteBorderComponents[m] replaces components adjacent to the border in a label matrix m with 0.

DeleteCases

DeleteCases[expr,pattern] removes all elements of expr that match pattern. 

DeleteCases[expr,pattern,levelspec] removes all parts of expr on levels specified by levelspec that match pattern. 

DeleteCases[expr,pattern,levelspec,n] removes the first n parts of expr that match pattern. 

DeleteCases[pattern] represents an operator form of DeleteCases that can be applied to an expression.

DeleteChannel

DeleteChannel[channel] deletes the specified channel from the channel broker server.

DeleteChannel[{channel1,channel2,…}] deletes all the channeli.

DeleteChannel[All] deletes all channels owned by the currently authenticated user.

DeleteContents

DeleteContents is an option for DeleteDirectory that specifies whether the contents of directories should automatically be deleted.

DeleteDirectory

DeleteDirectory["dir"] deletes the specified directory. 

DeleteDuplicates

DeleteDuplicates[data] deletes all duplicates from data.

DeleteDuplicates[data,test] applies test to pairs of elements to determine whether they should be considered duplicates. 

DeleteDuplicatesBy

DeleteDuplicatesBy[data,f] deletes those ei in data that yield duplicates in the list {f[e1],f[e2],…}.

DeleteDuplicatesBy[f] represents an operator form of DeleteDuplicatesBy that can be applied to an expression.

DeleteFile

DeleteFile["file"] deletes a file. 

DeleteFile[{"file1","file2",…}] deletes a list of files. 

DeleteMissing

DeleteMissing[list] drops elements with head Missing from a list.

DeleteMissing[assoc] drops elements whose values have head Missing from the association assoc.

DeleteMissing[expr,n] applies DeleteMissing to any lists or associations that occur within the first n levels of expr.

DeleteMissing[expr,n,d] considers an element at level n to be missing if Missing occurs within the first d levels of the element.

DeleteObject

DeleteObject[obj] deletes the object obj.

DeleteObject[{obj1,obj2,…}] deletes all the obji.

DeletePermissionsKey

DeletePermissionsKey[key] deletes a permissions key, rendering it invalid.

DeletePermissionsKey[{key1,key2,…}] deletes several permissions keys.

DeleteSearchIndex

DeleteSearchIndex[obj] deletes the search index represented by the search index object obj.

DeleteSearchIndex["name"] deletes the search index with the specified name in the SearchIndices[] list.

DeleteSmallComponents

DeleteSmallComponents[image] replaces small connected components in a binary image image with background pixels.

DeleteSmallComponents[m] replaces positive integers in a label matrix m with 0 if their tally is small.

DeleteSmallComponents[…,n] replaces components consisting of n or fewer elements.

DeleteStopwords

DeleteStopwords[list] deletes stopwords from a list of words.

DeleteStopwords["string"] deletes stopwords from a string.

DeleteStopwords[{string1,string2,…}] deletes stopwords from a list of strings.

DelimitedSequence

DelimitedSequence[form] represents a delimited sequence of elements of the specified form in Interpreter and related functions.

DelimitedSequence[form,sep] assumes a separator that matches sep.

DelimitedSequence[form,{left,sep,right}] assumes left and right delimiters matching left and right, respectively.

Delimiter

Delimiter represents a delimiter to be displayed in objects such as PopupMenu, Manipulate, and FormObject. 

DelimiterMatching

DelimiterMatching is an option for selections that specifies whether an opening delimiter will match only its respective closing delimiter or any closing delimiter.

Delimiters

Delimiters is an option to various functions that specifies what delimiters to use or look for.

DeliveryFunction

DeliveryFunction is an option that specifies how material such as documents generated by DocumentGenerator should be delivered.

Dendrogram

Dendrogram[{e1,e2,…}] constructs a dendrogram from the hierarchical clustering of the elements e1, e2, ….

Dendrogram[{e1->v1,e2->v2,…}] represents ei with vi in the constructed dendrogram.

Dendrogram[{e1,e2,…}->{v1,v2,…}] represents ei with vi in the constructed dendrogram.

Dendrogram[<|label1->e1,label2->e2,…|>] represents ei using labels labeli in the constructed dendrogram.

Dendrogram[data,orientation] constructs an oriented dendrogram according to orientation.

Dendrogram[tree] constructs the dendrogram corresponding to weighted tree tree. 

Denominator

Denominator[expr] gives the denominator of expr. 

DensityGraphics

DensityGraphics[array] is a representation of a density plot. 

DensityHistogram

DensityHistogram[{{x1,y1},{x2,y2},…}] plots a density histogram of the values {xi,yi}.

DensityHistogram[{{x1,y1},{x2,y2},…},bspec] plots a density histogram with bins specified by bspec.

DensityHistogram[{{x1,y1},{x2,y2},…},bspec,hspec] plots a density histogram with bin densities computed according to the specification hspec.

DensityPlot

DensityPlot[f,{x,xmin,xmax},{y,ymin,ymax}] makes a density plot of f as a function of x and y. 

DensityPlot[f,{x,y}∈reg] takes the variables {x,y} to be in the geometric region reg. 

DensityPlot3D

DensityPlot3D[f,{x,xmin,xmax},{y,ymin,ymax},{z,zmin,zmax}] makes a density plot of f as a function of x, y, and z.

DensityPlot3D[f,{x,y,z}∈reg] takes the variables to be in the geometric region reg.

DependentVariables

DependentVariables is an option for NDSolve and other functions that specifies the list of all objects that should be considered as dependent variables in equations that have been supplied.

Depth

Depth[expr] gives the maximum number of indices needed to specify any part of expr, plus 1. 

DepthFirstScan

DepthFirstScan[g,s,{event1->f1,event2->f2,…}] performs a depth-first scan of the graph g starting at the vertex s and evaluates fi whenever "eventi" occurs.

DepthFirstScan[g,{event1->f1,event2->f2,…}] performs a depth-first scan of the whole graph g.

DepthFirstScan[{v->w,…},…] uses rules v->w to specify the graph g.

Derivative

f' represents the derivative of a function f of one argument. 

Derivative[n1,n2,…][f] is the general form, representing a function obtained from f by differentiating n1 times with respect to the first argument, n2 times with respect to the second argument, and so on. 

DerivativeFilter

DerivativeFilter[data,{n1,n2,…}] computes the nith derivative of data at level i.

DerivativeFilter[data,{n1,n2,…},σ] computes the derivative at a Gaussian scale of standard deviation σ.

DerivativeFilter[data,{der1,der2,…},…] computes several derivatives der1, der2, ….

DerivativePDETerm

DerivativePDETerm[vars,γ] represents a load derivative term ∇{x1,…,xn}·(γ) with load derivative coefficient γ and model variables vars.

DerivativePDETerm[vars,γ,pars] uses model parameters pars.

DerivedKey

DerivedKey[assoc] represents a derived key generated by GenerateDerivedKey.

DescriptorStateSpace

DescriptorStateSpace is an option to StateSpaceModel and StateSpaceTransform that specifies whether to use descriptor or standard representation.

DesignMatrix

DesignMatrix[{{x11,x12,…,y1},{x21,x22,…,y2},…},{f1,f2,…},{x1,x2,…}] constructs the design matrix for the linear model β0+β1 f1+β2 f2+….

Det

Det[m] gives the determinant of the square matrix m. 

DeviceClose

DeviceClose[device] closes the connection to a device and frees related resources.

DeviceConfigure

DeviceConfigure[device,config] configures the specified device according to config.

DeviceExecute

DeviceExecute[device,"command"] executes the specified command on a device.

DeviceExecute[device,"command",params] executes the command with the parameters params.

DeviceExecuteAsynchronous

DeviceExecuteAsynchronous[device,"command",fun] initiates asynchronous execution of the specified command on a device, calling the handler function fun when an event occurs.

DeviceExecuteAsynchronous[device,"command",params,fun] executes the command with the parameters params.

DeviceObject

DeviceObject[…] represents a device that can be accessed in a Wolfram Language session.

DeviceOpen

DeviceOpen["devclass"] opens a connection to the first available device in the class specified by "devclass".

DeviceOpen["devclass",spec] opens a connection to the particular device defined by spec.

DeviceOpen[device] opens a connection to an existing device specified by a DeviceObject.

DeviceRead

DeviceRead[devobj] reads a single default item from the open device corresponding to the specified DeviceObject.

DeviceRead["devclass"] reads from the default device in the class "devclass".

DeviceRead[device,param] reads the parameter param from the specified device.

DeviceRead[device,{param1,param2,…}] reads the list of parameters parami from the specified device.

DeviceReadBuffer

DeviceReadBuffer[device] reads the complete contents of the buffer on a device.

DeviceReadBuffer[device,n] reads n elements from the buffer.

DeviceReadBuffer[device,crit] reads elements from the buffer until the device-specific criterion crit is met.

DeviceReadBuffer[device,crit,param] reads elements associated with the parameter param. 

DeviceReadBuffer[device,crit,{param1,param2,…}] reads elements associated with the parami.

DeviceReadLatest

DeviceReadLatest[device] returns the most recently collected default item from a device.

DeviceReadLatest[device,n] returns a list of the n most recently collected items.

DeviceReadLatest[device,n,param] returns the n most recently collected values of param.

DeviceReadLatest[device,n,{param1,param2,…}] returns a list of the most recently collected values of the parami.

DeviceReadList

DeviceReadList[device,n] reads from the specified device n times, returning a list of the results.

DeviceReadList[device,n,param] reads the parameter param.

DeviceReadList[device,n,{param1,param2,…}] reads the list of parameters parami.

DeviceReadTimeSeries

DeviceReadTimeSeries[device,{t,dt}] repeatedly reads default items from the specified device at interval dt for a total time t, returning a time series of the resulting values.

DeviceReadTimeSeries[device,{t,dt},param] repeatedly reads the parameter param and returns a time series of its values.

DeviceReadTimeSeries[device,{t,dt},{param1,param2,…}] repeatedly reads the parami and returns a time series of their values.

Devices

Devices[] gives a list of registered devices on a particular system.

Devices[form] gives a list of devices in classes whose names match the string pattern form.

Devices[{form1,form2,…}] gives a list of devices in classes whose names match any of the formi.

DeviceStreams

DeviceStreams[device] gives a list of all open streams associated with a device.

DeviceStreams[device,patt] gives a list of streams whose names match the string pattern patt.

DeviceStreams[device,{patt1,patt2,…}] gives a list of streams whose names match any of the patti.

DeviceWrite

DeviceWrite[device,val] writes the value val to the specified device.

DeviceWrite[device,{val1,val2,…}] writes the sequence of values vali to the specified device.

DeviceWrite[device,param->val] writes val as the value of the parameter param.

DeviceWrite[device,{param1->val1,param2->val2,…}] writes values of several parameters.

DeviceWriteBuffer

DeviceWriteBuffer[device,vals] fills the buffer on a device with the values vals.

DeviceWriteBuffer[device,param->vals] fills the buffer associated with the parameter param with the values vals.

DeviceWriteBuffer[device,{param1->vals1,param2->vals2,…}] fills the buffers associated with the parami with the corresponding values valsi .

DGaussianWavelet

DGaussianWavelet[] represents a derivative of Gaussian wavelet of derivative order 2.

DGaussianWavelet[n] represents a derivative of Gaussian wavelet of derivative order n.

DiagonalizableMatrixQ

DiagonalizableMatrixQ[m] gives True if m is diagonalizable, and False otherwise. 

Dialog

Dialog[] initiates a dialog. 

Dialog[expr] initiates a dialog with expr as the current value of %. 

Diamond

Diamond[x,y,…] displays as x⋄y⋄….

DiceDissimilarity

DiceDissimilarity[x,y] gives the Dice dissimilarity between Boolean vectors x and y.

DictionaryLookup

DictionaryLookup[patt] finds all words in an English dictionary that match the string pattern patt.

DictionaryLookup[patt,n] gives only the first n words found.

DictionaryLookup[{"lang",patt}] finds words in the language specified by lang.

DictionaryWordQ

DictionaryWordQ["word"] tests whether "word" is a recognized dictionary word.

DifferenceQuotient

DifferenceQuotient[f,{x,h}]  gives the difference quotient (f(x+h)-f(x))/h.

DifferenceQuotient[f,{x,n,h}] gives a multiple difference quotient with step h.

DifferenceQuotient[f,{x1,n1,h1},{x2,n2,h2},…] computes the partial difference quotient with respect to x1,x2,….

DifferenceRoot

DifferenceRoot[lde][k] gives the holonomic sequence h(k), specified by the linear difference equation lde[h,k].

DifferenceRoot[lde] represents a pure holonomic sequence h.

DifferenceRootReduce

DifferenceRootReduce[expr,n] attempts to reduce expr to a single DifferenceRoot object as a function of n.

DifferentialD

DifferentialD[x] displays as x.

DifferentialRoot

DifferentialRoot[lde][x] gives the holonomic function h(x), specified by the linear differential equation lde[h,x].

DifferentialRoot[lde] represents a pure holonomic function h. 

DifferentialRootReduce

DifferentialRootReduce[expr,x] attempts to reduce expr to a single DifferentialRoot object as a function of x.

DifferentialRootReduce[expr,{x,x0}] takes the initial conditions to be specified at x=x0.

DifferentiatorFilter

DifferentiatorFilter[data,ωc] applies a differentiator filter with a cutoff frequency ωc to an array of data.

DifferentiatorFilter[data,ωc,n] uses a filter kernel of length n.

DifferentiatorFilter[data,ωc,n,wfun] applies a smoothing window wfun to the filter kernel.

DiffusionPDETerm

DiffusionPDETerm[vars] represents a diffusion term ∇{x1,…,xn}·(-∇{x1,…,xn}u) with model variables vars.

DiffusionPDETerm[vars,c] represents a diffusion term ∇{x1,…,xn}·(-c∇{x1,…,xn}u) with diffusion coefficient c.

DiffusionPDETerm[vars,c,pars] uses model parameters pars.

DigitalSignature

DigitalSignature[assoc] represents a digital signature object.

DigitBlock

DigitBlock is an option for NumberForm and related functions that specifies the maximum length of blocks of digits between breaks. 

DigitCharacter

DigitCharacter represents a digit character 0–9 in StringExpression. 

DigitCount

DigitCount[n,b,d] gives the number of d digits in the base-b representation of n. 

DigitCount[n,b,d,len] gives the number of d digits in the base-b representation of the last len digits of n. 

DigitCount[n,b] gives a list of the numbers of 1, 2, …, b-1, 0 digits in the base-b representation of n. 

DigitCount[n] gives a list of the numbers of 1, 2, …, 9, 0 digits in the base-10 representation of n. 

DigitQ

DigitQ[string] yields True if all the characters in the string are digits in the range 0 through 9, and yields False otherwise. 

DihedralAngle

DihedralAngle[{p1,p2},{v,w}] gives the angle between two half-planes bounded by the line through p1 and p2 and extended in the direction v and w. 

DihedralGroup

DihedralGroup[n] represents the dihedral group of order 2n.

Dilation

Dilation[image,ker] gives the morphological dilation of image with respect to the structuring element ker.

Dilation[image,r] gives the dilation with respect to a range-r square.

Dilation[data,…] applies dilation to an array of data.

DimensionalCombinations

DimensionalCombinations[{pq1,pq2,…}] returns the possible combinations of the list of physical quantities pqi that are dimensionless.

DimensionalCombinations[{pq1,pq2,…},dim] returns the possible combinations of the list of physical quantities pqi that match the dimensions of physical quantity dim.

DimensionalMeshComponents

DimensionalMeshComponents[mr] gives a list {r0,r1,…} of regions such that rd has dimension d for a mesh region mr.

DimensionReduce

DimensionReduce[{example1,example2,…}] projects the examples examplei to a lower-dimensional approximating manifold.

DimensionReduce[examples,n] projects onto an approximating manifold in n-dimensional space. 

DimensionReducerFunction

DimensionReducerFunction[…] represents a function generated by DimensionReduction that projects data onto a lower-dimensional approximating manifold.

DimensionReduction

DimensionReduction[{example1,example2,…}] generates a DimensionReducerFunction[…] that projects from the space defined by the examplei to a lower-dimensional approximating manifold.

DimensionReduction[examples,n] generates a DimensionReducerFunction[…] for an n-dimensional approximating manifold. 

DimensionReduction[examples,n,props] generates the specified properties of the dimensionality reduction. 

Dimensions

Dimensions[expr] gives a list of the dimensions of expr. 

Dimensions[expr,n] gives a list of the dimensions of expr down to level n. 

DiracComb

DiracComb[x] represents the Dirac comb function (x) giving a delta function at every integer point. 

DiracComb[x1,x2,…] represents the multidimensional Dirac comb function (x1,x2,…).

DiracDelta

DiracDelta[x] represents the Dirac delta function δ(x). 

DiracDelta[x1,x2,…] represents the multidimensional Dirac delta function δ(x1,x2,…). 

DirectedEdge

DirectedEdge[u,v] or uv represents a directed edge from u to v.

DirectedEdge[u,v,t] or u&tv represents a directed edge from u to v with tag t.

DirectedEdges

DirectedEdges is an option for Graph, GraphPlot, and related functions that specifies whether edges should be taken to be directed.

DirectedGraph

DirectedGraph[g] gives a directed graph from the undirected graph g.

DirectedGraph[g,conv] gives a directed graph using the conversion conv.

DirectedGraph[{v->w,…},…] uses rules v->w to specify the graph g.

DirectedGraphQ

DirectedGraphQ[g] yields True if the graph g is a directed graph and False otherwise.

DirectedInfinity

DirectedInfinity[] represents an infinite numerical quantity whose direction in the complex plane is unknown. 

DirectedInfinity[z] represents an infinite numerical quantity that is a positive real multiple of the complex number z. 

Direction

Direction is an option for Limit and related functions that specifies the direction in which the limit is taken.

DirectionalLight

DirectionalLight[col,pt] is a three–dimensional graphics directive that specifies the directional light of color col from the point pt to the center of the bounding box to use in coloring 3D surfaces.

DirectionalLight[col,{pt1,pt2}] uses a directional light along the vector from pt1 to pt2.

Directive

Directive[g1,g2,…] represents a single graphics directive composed of the directives g1, g2, ….

Directory

Directory[] gives the current working directory. 

DirectoryName

DirectoryName["name"] extracts the directory name from the specification for a file. 

DirectoryQ

DirectoryQ["name"] gives True if the directory with the specified name exists, and gives False otherwise.

DirectoryStack

DirectoryStack[] gives the directory stack that represents the sequence of current directories used. 

DirichletBeta

DirichletBeta[s] gives the Dirichlet beta function β(s).

DirichletCharacter

DirichletCharacter[k,j,n] gives the Dirichlet character χk,j(n) with modulus k and index j.

DirichletCondition

DirichletCondition[beqn,pred] represents a Dirichlet boundary condition given by equation beqn, satisfied on the part of the boundary of the region given to NDSolve and related functions where pred is True.

DirichletConvolve

DirichletConvolve[f,g,n,m] gives the Dirichlet convolution of the expressions f and g. 

DirichletDistribution

DirichletDistribution[{α1,…,αk+1}] represents a Dirichlet distribution of dimension k with shape parameters αi.

DirichletEta

DirichletEta[s] gives the Dirichlet eta function η(s).

DirichletL

DirichletL[k,j,s] gives the Dirichlet L-function L(χ,s) for the Dirichlet character χ(n) with modulus k and index j.

DirichletLambda

DirichletLambda[s] gives the Dirichlet lambda function λ(s).

DirichletTransform

DirichletTransform[expr,n,s] gives the Dirichlet transform of expr with respect to n.

DirichletWindow

DirichletWindow[x] represents a Dirichlet window function of x.

DiscreteAsymptotic

DiscreteAsymptotic[expr,n->∞] gives an asymptotic approximation for expr as n tends to infinity over the integers.

DiscreteAsymptotic[expr,{n,∞,m}] gives an asymptotic series approximation for expr to order m.

DiscreteChirpZTransform

DiscreteChirpZTransform[list] gives the chirp Z transform of list.

DiscreteChirpZTransform[list,n] returns a length n chirp Z transform.

DiscreteChirpZTransform[list,n,w] uses a spiral path on the complex z plane defined by w.

DiscreteChirpZTransform[list,n,w,a] uses a as the complex starting point.

DiscreteChirpZTransform[list,{n1,n2,…},{w1,w2,…},{a1,a2,…}] gives the multidimensional chirp Z transform. 

DiscreteConvolve

DiscreteConvolve[f,g,n,m] gives the convolution with respect to n of the expressions f and g. 

DiscreteConvolve[f,g,{n1,n2,…},{m1,m2,…}] gives the multidimensional convolution.

DiscreteDelta

DiscreteDelta[n1,n2,…] gives the discrete delta function δ(n1,n2,…), equal to 1 if all the ni are zero, and 0 otherwise. 

DiscreteHadamardTransform

DiscreteHadamardTransform[list] gives the discrete Hadamard transform of list.

DiscreteIndicator

DiscreteIndicator[x,x1,{u1,u2,…}] yields the discrete indicator function, equal to 1 if x=x1 and, otherwise, to 0 if x=ui for some i.

DiscreteLQEstimatorGains

DiscreteLQEstimatorGains[ssm,{w,v},τ] gives the optimal discrete-time estimator gain matrix with sampling period τ for the continuous-time StateSpaceModel ssm, with process and measurement noise covariance matrices w and v.

DiscreteLQEstimatorGains[{ssm,sensors},{w,v},τ] specifies sensors as the noisy measurements of ssm.

DiscreteLQEstimatorGains[{ssm,sensors,dinputs},{w,v},τ] specifies dinputs as the deterministic inputs of ssm.

DiscreteLQRegulatorGains

DiscreteLQRegulatorGains[sspec,wts,τ] gives the discrete-time state feedback gains with sampling period τ for the continuous-time system specification sspec that minimizes a cost function with weights wts.

DiscreteLQRegulatorGains[…,"prop"] gives the value of the property "prop".

DiscreteLyapunovSolve

DiscreteLyapunovSolve[a,c] finds the numeric solution x of the discrete matrix equation a.x.a-xc.

DiscreteLyapunovSolve[a,b,c] solves a.x.b-xc.

DiscreteLyapunovSolve[{a,d},c] solves a.x.a-d.x.dc.

DiscreteLyapunovSolve[{a,d},{b,e},c] solves a.x.b-d.x.ec.

DiscreteMarkovProcess

DiscreteMarkovProcess[i0,m] represents a discrete-time, finite-state Markov process with transition matrix m and initial state i0.

DiscreteMarkovProcess[p0,m] represents a Markov process with initial state probability vector p0.

DiscreteMarkovProcess[…,g] represents a Markov process with transition matrix from the graph g.

DiscretePlot

DiscretePlot[f,{n,nmax}] generates a plot of f as a function of n when n=1,…,nmax.

DiscretePlot[f,{n,nmin,nmax}] generates a plot when n runs from nmin to nmax.

DiscretePlot[f,{n,nmin,nmax,dn}] uses steps dn. 

DiscretePlot[f,{n,{n1,…,nm}}] uses the successive values n1, …, nm.

DiscretePlot[{f1,f2,…},…] plots the values of all the fi.

DiscretePlot3D

DiscretePlot3D[f,{i,imin,imax},{j,jmin,jmax}] generates a plot of f when i runs from imin to imax and j runs from jmin to jmax.

DiscretePlot3D[f,{i,imin,imax,di},{j,jmin,jmax,dj}] uses steps di and dj.

DiscretePlot3D[f,{i,{i1,…,im}},{j,{j1,…,jn}}] uses successive i values i1, …, jm and j values j1, …, jn. 

DiscretePlot3D[{f1,f2,…},…,…] plots the values of all the fk.

DiscreteRatio

DiscreteRatio[f,i] gives the discrete ratio f(i+1)/f(i).

DiscreteRatio[f,{i,n}] gives the multiple discrete ratio.

DiscreteRatio[f,{i,n,h}] gives the multiple discrete ratio with step h. 

DiscreteRatio[f,i,j,…] computes the partial difference ratio with respect to i, j, ….

DiscreteTimeModelQ

DiscreteTimeModelQ[lsys] gives True if lsys is a discrete-time systems model, and False otherwise.

DiscreteUniformDistribution

DiscreteUniformDistribution[{imin,imax}] represents a discrete uniform distribution over the integers from imin to imax.

DiscreteUniformDistribution[{{imin,imax},{jmin,jmax},…}] represents a multivariate discrete uniform distribution over integers within the box {{imin,imax},{jmin,jmax},…}.

DiscreteVariables

DiscreteVariables is an option for NDSolve and other functions that specifies variables that only change at discrete times in a temporal integration.

DiscreteWaveletData

DiscreteWaveletData[{wind1->coef1,…},wave,wtrans] yields a discrete wavelet data object with wavelet coefficients coefi corresponding to wavelet index windi, wavelet wave, and wavelet transform wtrans.

DiscreteWaveletData[{wind1->coef1,…},wave,wtrans,{d1,…}] yields a discrete wavelet data object assuming data dimensions {d1,…}.

DiscreteWaveletPacketTransform

DiscreteWaveletPacketTransform[data] gives the discrete wavelet packet transform (DWPT) of an array of data.

DiscreteWaveletPacketTransform[data,wave] gives the discrete wavelet packet transform using the wavelet wave.

DiscreteWaveletPacketTransform[data,wave,r] gives the discrete wavelet packet transform using r levels of refinement.

DiscreteWaveletTransform

DiscreteWaveletTransform[data] gives the discrete wavelet transform (DWT) of an array of data.

DiscreteWaveletTransform[data,wave] gives the discrete wavelet transform using the wavelet wave.

DiscreteWaveletTransform[data,wave,r] gives the discrete wavelet transform using r levels of refinement.

DiscretizeGraphics

DiscretizeGraphics[g] discretizes a 2D or 3D graphic g into a MeshRegion.

DiscretizeGraphics[g,patt] discretizes only the elements in g that match the pattern patt.

DiscretizeRegion

DiscretizeRegion[reg] discretizes a region reg into a MeshRegion.

DiscretizeRegion[reg,{{xmin,xmax},…}] restricts to the bounds [xmin,xmax]×⋯.

Discriminant

Discriminant[poly,var] computes the discriminant of the polynomial poly with respect to the variable var.

Discriminant[poly,var,Modulus->p] computes the discriminant modulo p.

DisjointQ

DisjointQ[list1,list2] yields True if list1 and list2 do not share any common elements, and False otherwise.

Disjunction

Disjunction[expr,{a1,a2,…}] gives the disjunction of expr over all choices of the Boolean variables ai.

Disk

Disk[{x,y},r] represents a disk of radius r centered at {x,y}.

Disk[{x,y}] gives a disk of radius 1. 

Disk[{x,y},{rx,ry}] gives an axis-aligned elliptical disk with semiaxes lengths rx and ry.

Disk[{x,y},…,{θ1,θ2}] gives a sector of a disk from angle θ1 to θ2.

Disk[{{x1,y1},{x2,y2},…},…] gives multiple identical disks centered at the given coordinates.

DiskSegment

DiskSegment[{x,y},r,{θ1,θ2}] represents the disk segment from angle θ1 to θ2 in a disk centered at {x,y} of radius r.

DiskSegment[{x,y},{rx,ry},{θ1,θ2}] represents the ellipse segment from angle θ1 to θ2 in an axis-aligned ellipse with semiaxes lengths rx and ry.

Dispatch

Dispatch[{lhs1->rhs1,lhs2->rhs2,…}] generates an optimized dispatch table representation of a list of rules. The object produced by Dispatch can be used to give the rules in expr/.rules. 

DispersionEstimatorFunction

DispersionEstimatorFunction is an option for generalized linear model fitting functions that specifies the estimator for the dispersion parameter.

Display

Display[channel,graphics] writes graphics or sound to the specified output channel in PostScript format. 

Display[channel,graphics,"format"] writes graphics or sound in the specified format. 

Display[channel,expr,"format"] writes boxes, cells, or notebook expressions in the specified format. 

DisplayAllSteps

DisplayAllSteps is an option to Animate and related functions that specifies whether all frames should be displayed in an animation, even if to do so would slow the animation down.

DisplayEndPacket

DisplayEndPacket[] is a WSTP packet that indicates the end of a series of expressions relating to a postscript graphic.

DisplayFunction

DisplayFunction is an option for graphics and sound functions that specifies a function to apply to graphics and sound objects before returning them.

DisplayPacket

DisplayPacket[] is a WSTP packet that indicates the beginning of a series of expressions related to a PostScript graphic.

DisplayString

DisplayString[graphics] generates a string giving graphics or sound in PostScript format. 

DisplayString[graphics,"format"] generates a string giving graphics or sound in the specified format. 

DisplayString[expr,"format"] generates a string giving boxes, cells, or notebook expressions in the specified format. 

DistanceFunction

DistanceFunction is an option for functions such as Nearest that specifies the distance value to assume between any two specified points.

DistanceMatrix

DistanceMatrix[{u1,u2,…}] gives the matrix of distances between each pair of elements ui, uj. 

DistanceMatrix[{u1,u2,…},{v1,v2,…}] gives the matrix of distances between each pair of elements ui, vj.

DistanceTransform

DistanceTransform[image] gives the distance transform of image, in which the value of each pixel is replaced by its distance to the nearest background pixel.

DistanceTransform[image,t] treats values above t as foreground.

Distribute

Distribute[f[x1,x2,…]] distributes f over Plus appearing in any of the xi. 

Distribute[expr,g] distributes over g. 

Distribute[expr,g,f] performs the distribution only if the head of expr is f. 

Distributed

Distributed[x,dist] or xdist asserts that the random variable x is distributed according to the probability distribution dist.

Distributed[{x1,x2,…},dist] or {x1,x2,…}dist asserts that the random vector {x1,x2,…} is distributed according to the multivariate probability distribution dist.

DistributedContexts

DistributedContexts is an option for various parallel computing functions that specifies which definitions for symbols appearing in an expression should be distributed to all parallel kernels.

DistributeDefinitions

DistributeDefinitions[s1,s2,…] distributes all definitions for the symbols si to all parallel kernels.

DistributeDefinitions["context`"] distributes definitions for all symbols in the specified context.

DistributionChart

DistributionChart[{data1,data2,…}] makes a distribution chart with a distribution symbol for each datai.

DistributionChart[{…,wi[datai,…],…,wj[dataj,…],…}] makes a distribution chart with symbol features defined by the symbolic wrappers wk.

DistributionChart[{{data1,data2,…},…}] makes a distribution chart from multiple groups of datasets {data1,data2,…}.

DistributionFitTest

DistributionFitTest[data] tests whether data is normally distributed. 

DistributionFitTest[data,dist] tests whether data is distributed according to dist. 

DistributionFitTest[data,dist,"property"] returns the value of "property".

DistributionParameterAssumptions

DistributionParameterAssumptions[dist] gives a logical expression for assumptions on parameters in the symbolic distribution dist.

DistributionParameterQ

DistributionParameterQ[dist] yields True if dist is a valid distribution, and yields False otherwise.

Dithering

Dithering is an option for ColorQuantize that specifies whether or not to apply dithering while quantizing the pixel values.

Div

Div[{f1,…,fn},{x1,…,xn}] gives the divergence ∂f1/∂x1+…+∂fn/∂xn.

Div[{f1,…,fn},{x1,…,xn},chart] gives the divergence in the coordinates chart.

Divide

x/y or Divide[x,y] is equivalent to x y^-1. 

DivideBy

x/=c divides x by c and returns the new value of x. 

Dividers

Dividers is an option for Grid and related constructs that specifies where and how to draw divider lines.

DivideSides

DivideSides[rel,x] divides each side of the equation or inequality rel by x.

DivideSides[rel1,rel2] divides the corresponding sides of two equations or inequalities.

DivideSides[rel] divides each side of rel by the right-hand side, producing a 1 right-hand side.

Divisible

Divisible[n,m] yields True if n is divisible by m, and yields False if it is not. 

Divisors

Divisors[n] gives a list of the integers that divide n. 

DivisorSigma

DivisorSigma[k,n] gives the divisor function σk(n). 

DivisorSum

DivisorSum[n,form] represents the sum of form[i] for all i that divide n.

DivisorSum[n,form,cond] includes only those divisors for which cond[i] gives True.

DMSList

DMSList[θ] converts an angle θ given in decimal degrees to a DMS list {degree,minute,second}.

DMSList["dms"] converts a DMS string to a DMS list {degree,minute,second}.

DMSList["latlon"] converts a latitude-longitude string to a pair of DMS lists.

DMSList[GeoPosition[…]] converts GeoPosition data to a pair or array of pairs of DMS lists.

DMSString

DMSString[θ] converts an angle θ given in decimal degrees to a degrees-minutes-seconds string.

DMSString[{ϕ,λ}] converts latitude and longitude given in decimal degrees to a DMS latitude-longitude string.

DMSString[{d,m,s}] converts a DMS list to a DMS string.

Do

Do[expr,n] evaluates expr n times. 

Do[expr,{i,imax}] evaluates expr with the variable i successively taking on the values 1 through imax (in steps of 1). 

Do[expr,{i,imin,imax}] starts with i=imin. 

Do[expr,{i,imin,imax,di}] uses steps di. 

Do[expr,{i,{i1,i2,…}}] uses the successive values i1, i2, ….

Do[expr,{i,imin,imax},{j,jmin,jmax},…] evaluates expr looping over different values of j etc. for each i. 

DocumentGenerator

DocumentGenerator[template,timespec] represents a document generator with template template to be evaluated on the schedule defined by timespec.

DocumentGenerator[template,driver,timespec] takes parameters for filling the template from driver.

DocumentGeneratorInformation

DocumentGeneratorInformation[cloudobj] returns the properties of the DocumentGenerator cloudobj.

DocumentGeneratorInformation[cloudobj,property] returns the value of the property property.

DocumentWeightingRules

DocumentWeightingRules is an option for TextSearch and related functions that allows the specification of weights for documents based on the values of fields in the search index. 

Dodecahedron

Dodecahedron[] represents a regular dodecahedron centered at the origin with unit edge length.

Dodecahedron[l] represents a dodecahedron with edge length l.

Dodecahedron[{θ,ϕ},…] represents a dodecahedron rotated by an angle θ with respect to the z axis and angle ϕ with respect to the y axis.

Dodecahedron[{x,y,z},…] represents a dodecahedron centered at {x,y,z}.

DominantColors

DominantColors[image] returns dominant colors in image.

DominantColors[image,n] returns at most n dominant colors in image.

DominantColors[image,n,prop] returns the specified property prop for the regions that belong to the same dominant color.

DominantColors[image,n,prop,format] returns the output in the specified format.

DominantColors[{image1,image2,…},…] returns dominant colors in each imagei.

DominatorTreeGraph

DominatorTreeGraph[g,r] gives the dominator tree of the directed graph g from the root vertex r.

DominatorVertexList

DominatorVertexList[g,r] gives the list of dominators of the directed graph g from the root vertex r. 

DOSTextFormat

DOSTextFormat is an option for OpenRead, OpenWrite, and OpenAppend that specifies whether files should be opened in text mode. With DOSTextFormat -> True, Mathematica uses the normal text format for the type of computer on which Mathematica is running. Text mode typically entails translation of a text file's line-ending characters into the newline character "\n". With DOSTextFormat -> False, files are opened in "binary mode", in which no such translation is performed. On some systems, there is no difference between text mode and binary mode.

Dot

a.b.c or Dot[a,b,c] gives products of vectors, matrices, and tensors. 

DotDashed

DotDashed is a graphics directive specifying that lines that follow should be drawn dot-dashed.

DotEqual

DotEqual[x,y,…] displays as x≐y≐….

DotLayer

DotLayer[] represents a net layer that takes the dot product of two or more arrays.

DotLayer[{spec1,spec2,…}] uses given transpose specifications for the respective inputs.

DotPlusLayer

DotPlusLayer[n] is equivalent to LinearLayer[n] and should no longer be used. 

Dotted

Dotted is a graphics directive specifying that lines that follow should be drawn dotted.

DoubleBracketingBar

DoubleBracketingBar[x,y,…] displays as x,y,….

DoubleDownArrow

DoubleDownArrow[x,y,…] displays as x⇓�.

DoubleLeftArrow

DoubleLeftArrow[x,y,…] displays as x⇐y⇐….

DoubleLeftRightArrow

DoubleLeftRightArrow[x,y,…] displays as x⇔y⇔….

DoubleLeftTee

DoubleLeftTee[x,y] displays as x⫤y.

DoubleLongLeftArrow

DoubleLongLeftArrow[x,y,…] displays as x⟸y⟸….

DoubleLongLeftRightArrow

DoubleLongLeftRightArrow[x,y,…] displays as x⟺y⟺….

DoubleLongRightArrow

DoubleLongRightArrow[x,y,…] displays as x⟹y⟹….

DoubleRightArrow

DoubleRightArrow[x,y,…] displays as x⇒y⇒….

DoubleRightTee

DoubleRightTee[x,y] displays as x⊨y.

DoubleUpArrow

DoubleUpArrow[x,y,…] displays as x⇑y⇑….

DoubleUpDownArrow

DoubleUpDownArrow[x,y,…] displays as x⇕y⇕….

DoubleVerticalBar

DoubleVerticalBar[x,y,…] displays as x∥y∥….

DoublyInfinite

DoublyInfinite is an option for LerchPhi. With DoublyInfinite -> True, the summation is taken from -Infinity to Infinity. With DoublyInfinite -> False, the summation is taken from zero to Infinity.

DownArrow

DownArrow[x,y,…] displays as x↓y↓….

DownArrowBar

DownArrowBar[x,y,…] displays as x⤓y⤓….

DownArrowUpArrow

DownArrowUpArrow[x,y,…] displays as x⇵y⇵….

DownLeftRightVector

DownLeftRightVector[x,y,…] displays as x⥐y⥐….

DownLeftTeeVector

DownLeftTeeVector[x,y,…] displays as x⥞y⥞….

DownLeftVector

DownLeftVector[x,y,…] displays as x↽y↽….

DownLeftVectorBar

DownLeftVectorBar[x,y,…] displays as x⥖y⥖….

DownRightTeeVector

DownRightTeeVector[x,y,…] displays as x⥟y⥟….

DownRightVector

DownRightVector[x,y,…] displays as x⇁y⇁….

DownRightVectorBar

DownRightVectorBar[x,y,…] displays as x⥗y⥗….

Downsample

Downsample[array,n] returns a downsampled version of the array by sampling every nth element.

Downsample[array,n,offset] starts sampling from the element at position offset.

Downsample[image,…] downsamples an image.

DownTee

DownTee[x,y] displays as x⊤y.

DownTeeArrow

DownTeeArrow[x,y,…] displays as x↧y↧….

DownValues

DownValues[f] gives a list of transformation rules corresponding to all downvalues (values for f[…]) defined for the symbol f. 

DownValues["symbol"] gives a list of transformation rules corresponding to all downvalues defined for the symbol named "symbol" if it exists.

DrazinInverse

DrazinInverse[m] finds the Drazin generalized inverse mD of a square matrix m.

DropoutLayer

DropoutLayer[] represents a net layer that sets its input elements to zero with probability 0.5 during training.

DropoutLayer[p] sets its input elements to zero with probability p during training.

DSolve

DSolve[eqn] solves a differential equation eqn.

DSolve[eqn,u,x] solves a differential equation for the function u, with independent variable x. 

DSolve[eqn,u,{x,xmin,xmax}] solves a differential equation for x between xmin and xmax.

DSolve[{eqn1,eqn2,…},{u1,u2,…},…] solves a list of differential equations. 

DSolve[eqn,u,{x1,x2,…}] solves a partial differential equation. 

DSolve[eqn,u,{x1,x2,…}∈Ω] solves the partial differential equation eqn over the region Ω.

DSolveValue

DSolveValue[eqn,expr,x] gives the value of expr determined by a symbolic solution to the ordinary differential equation eqn with independent variable x. 

DSolveValue[eqn,expr,{x,xmin,xmax}] uses a symbolic solution for x between xmin and xmax.

DSolveValue[{eqn1,eqn2,…},expr,…] uses a symbolic solution for a list of differential equations. 

DSolveValue[eqn,expr,{x1,x2,…}] uses a solution for the partial differential equation eqn. 

DSolveValue[eqn,expr,{x1,x2,…}∈Ω] uses a solution of the partial differential equation eqn over the region Ω.

DualPlanarGraph

DualPlanarGraph[g] gives the dual of the planar graph g.

DualPolyhedron

DualPolyhedron[poly] gives the dual polyhedron of the polyhedron poly.

DumpGet

DumpGet[ "filename"] reads in a file saved with DumpSave.

DumpSave

DumpSave["file.mx",symbol] writes definitions associated with a symbol to a file in internal Wolfram System format. 

DumpSave["file.mx","context`"] writes out definitions associated with all symbols in the specified context. 

DumpSave["file.mx",{object1,object2,…}] writes out definitions for several symbols or contexts. 

DumpSave["package`",objects] chooses the name of the output file based on the computer system used. 

DuplicateFreeQ

DuplicateFreeQ[list] gives True if list has no duplicates, and False otherwise.

DuplicateFreeQ[list,test] applies test to pairs of elements to determine whether they should be considered duplicates.

Duration

Duration[expr] returns the duration of expr.

Duration[expr,unit] returns the result in the specified unit.

E

E is the exponential constant  (base of natural logarithms), with numerical value ≃2.71828.

EarthImpactData

EarthImpactData[entity,property] gives the value of the specified property for the earth impact crater entity.

EarthImpactData[{entity1,entity2,…},property] gives a list of property values for the specified earth impact crater names.

EarthImpactData[entity,property,annotation] gives the specified annotation associated with the given property.

EarthquakeData

EarthquakeData[loc] gives all earthquake properties for the location corresponding to loc.

EarthquakeData[loc,mag] restricts earthquakes returned to the magnitude range mag. 

EarthquakeData[loc,mag,{start,end}] gives earthquake data within the magnitude range mag during the time interval start to end.

EarthquakeData[loc,mag,{start,end},property] gives a time series for the specific earthquake property for earthquakes within the magnitude range mag during the time interval start to end.

EarthquakeData[entity,property] returns data for a specific earthquake. 

EccentricityCentrality

EccentricityCentrality[g] gives a list of eccentricity centralities for the vertices in the graph g.

EccentricityCentrality[{v->w,…}] uses rules v->w to specify the graph g.

Echo

Echo[expr] prints expr and returns expr.

Echo[expr,label] prints expr prepending label and returns expr.

Echo[expr,label,f] prints f[expr] prepending label and returns expr.

EchoEvaluation

EchoEvaluation[expr] prints expr before evaluation, then prints the result after evaluation and returns that result.

EchoEvaluation[expr,label] prepends label when printing expr before and after evaluation.

EchoEvaluation[expr,label1->label2] prepends label1 before evaluation and label2 after evaluation.

EchoEvaluation[expr,labels,f] prints expr before evaluation, then evaluates expr to the result res and prints f[res].

EchoEvaluation[expr,labels,g->f] prints g[expr] before evaluating expr and then f[res] after evaluation.

EchoFunction

EchoFunction[f][expr] prints f[expr] and returns expr.

EchoFunction[label,f][expr] prints f[expr] prepending label and returns expr.

EchoLabel

EchoLabel[label][expr] prints expr prepending label and returns expr.

EchoTiming

EchoTiming[expr] evaluates expr, prints the time in seconds used and returns the result of the evaluation.

EchoTiming[expr,label] prints the timing, prepending label.

EclipseType

EclipseType is an option for SolarEclipse and LunarEclipse that specifies the type of eclipse being queried for.

EdgeAdd

EdgeAdd[g,e] makes a graph by adding the edge e to the graph g.

EdgeAdd[g,{e1,e2,…}] adds a collection of edges to g.

EdgeAdd[{v->w,…},…] uses rules v->w to specify the graph g. 

EdgeBetweennessCentrality

EdgeBetweennessCentrality[g] gives a list of betweenness centralities for the edges in the graph g.

EdgeBetweennessCentrality[{v->w,…}] uses rules v->w to specify the graph g. 

EdgeCapacity

EdgeCapacity is an option and annotation for Graph and related functions that specifies an edge capacity.

EdgeChromaticNumber

EdgeChromaticNumber[g] gives the chromatic number for the edges of the graph g.

EdgeConnectivity

EdgeConnectivity[g] gives the edge connectivity of the graph g.

EdgeConnectivity[g,s,t] gives the s-t edge connectivity of the graph g.

EdgeConnectivity[{v->w,…},…] uses rules v->w to specify the graph g. 

EdgeContract

EdgeContract[g,e] contracts the edge e of the graph g.

EdgeContract[g,{e1,e2,…}] contracts a collection of edges e1,e2,….

EdgeContract[{v->w,…},…] uses rules v->w to specify the graph g. 

EdgeCost

EdgeCost is an option and annotation for Graph and related functions that specifies an edge cost.

EdgeCount

EdgeCount[g] gives a count of the number of edges in the graph g.

EdgeCount[g,patt] gives a count of the number of edges that match the pattern patt.

EdgeCount[{v->w,…},…] uses rules v->w to specify the graph g. 

EdgeCoverQ

EdgeCoverQ[g,elist] yields True if the edge list elist is an edge cover of the graph g and False otherwise.

EdgeCycleMatrix

EdgeCycleMatrix[g] gives the edge cycle matrix of a graph g.

EdgeCycleMatrix[{v->w,…}] uses rules v->w to specify the graph g. 

EdgeDelete

EdgeDelete[g,e] makes a graph by deleting the edge e from the graph g.

EdgeDelete[g,{e1,e2,…}] deletes a collection of edges from g.

EdgeDelete[g,patt] deletes all edges that match the pattern patt.

EdgeDelete[{v->w,…},…] uses rules v->w to specify the graph g. 

EdgeDetect

EdgeDetect[image] finds edges in image and returns the result as a binary image.

EdgeDetect[image,r] finds edges at the scale of the specified pixel range r.

EdgeDetect[image,r,t] uses a threshold t for selecting image edges.

EdgeForm

EdgeForm[g] is a graphics directive that specifies that edges of polygons and other filled graphics objects are to be drawn using the graphics directive or list of directives g. 

EdgeIndex

EdgeIndex[g,e] gives the integer index for the edge e in the graph g.

EdgeIndex[{v->w,…},…] uses rules v->w to specify the graph g. 

EdgeLabeling

EdgeLabeling is an option for GraphPlot and related functions that specifies whether labeling specified for edges should be displayed by default.

EdgeLabels

EdgeLabels is an option and annotation for Graph and related functions that specifies what labels and label positions should be used for edges. 

EdgeLabelStyle

EdgeLabelStyle is an option and property for Graph and related functions that specifies the style to use for edge labels.

EdgeList

EdgeList[g] gives the list of edges for the graph g.

EdgeList[g,patt] gives a list of edges that match the pattern patt.

EdgeList[{v->w,…},…] uses rules v->w to specify the graph g. 

EdgeQ

EdgeQ[g,e] yields True if e is an edge in the graph g and False otherwise.

EdgeRenderingFunction

EdgeRenderingFunction is an option for GraphPlot and related functions that gives a function to generate the graphics primitives to use in rendering each edge.

EdgeRules

EdgeRules[g] gives the list of edge rules for the graph g.

EdgeRules[{v->w,…}] uses rules v->w to specify the graph g. 

EdgeShapeFunction

EdgeShapeFunction is an option and annotation for Graph and related functions that specifies a function to use to generate primitives for rendering each edge. 

EdgeStyle

EdgeStyle is an option and annotation for Graph and related functions that specifies what style to use for edges. 

EdgeTaggedGraph

EdgeTaggedGraph[{e1,e2,…}] yields a graph with edges ej tagged with unique tags.

EdgeTaggedGraph[{e1,e2,…}->{t1,t2,…}] yields a graph with edges ej tagged with tj.

EdgeTaggedGraph[{v1,v2,…},{e1,e2,…}->{t1,t2,…}] yields a graph with vertices vi and edges ej tagged with tj.

EdgeTaggedGraph[{…,wi[vi],…},{…,wj[ej],…}->{t1,t2,…}] yields a graph with vertex and edge annotations defined by the symbolic wrappers wk.

EdgeTaggedGraphQ

EdgeTaggedGraphQ[g] yields True if the graph g has edges tagged and False otherwise.

EdgeTags

EdgeTags[g] gives the list of tags for all edges in the graph g.

EdgeTags[g,{u,v}] gives the list of tags for edges between u and v.

EdgeTransitiveGraphQ

EdgeTransitiveGraphQ[g] yields True if the graph g is a edge-transitive graph and False otherwise.

EdgeValueRange

EdgeValueRange is an option for GeoGraphValuePlot that specifies the range of edge values to include in a plot.

EdgeValueSizes

EdgeValueSizes is an option for GeoGraphValuePlot that specifies the thicknesses used to show edge values in a plot.

EdgeWeight

EdgeWeight is an option and annotation for Graph and related functions that specifies an edge weight.

EdgeWeightedGraphQ

EdgeWeightedGraphQ[g] yields True if the graph g is an edge-weighted graph and False otherwise.

EditDistance

EditDistance[u,v] gives the edit or Levenshtein distance between strings or vectors u and v.

EditDistance[u,v] gives the edit or Levenshtein distance between strings, vectors or biomolecular sequences u and v.

EffectiveInterest

EffectiveInterest[r,q] gives the effective interest rate corresponding to interest specification r, compounded at time intervals q.

Eigensystem

Eigensystem[m] gives a list {values,vectors} of the eigenvalues and eigenvectors of the square matrix m. 

Eigensystem[{m,a}] gives the generalized eigenvalues and eigenvectors of m with respect to a. 

Eigensystem[m,k] gives the eigenvalues and eigenvectors for the first k eigenvalues of m. 

Eigensystem[{m,a},k] gives the first k generalized eigenvalues and eigenvectors.

Eigenvalues

Eigenvalues[m] gives a list of the eigenvalues of the square matrix m. 

Eigenvalues[{m,a}] gives the generalized eigenvalues of m with respect to a. 

Eigenvalues[m,k] gives the first k eigenvalues of m. 

Eigenvalues[{m,a},k] gives the first k generalized eigenvalues.

EigenvectorCentrality

EigenvectorCentrality[g] gives a list of eigenvector centralities for the vertices in the graph g.

EigenvectorCentrality[g,"In"] gives a list of in-centralities for a directed graph g.

EigenvectorCentrality[g,"Out"] gives a list of out-centralities for a directed graph g.

EigenvectorCentrality[{v->w,…},…] uses rules v->w to specify the graph g.

Eigenvectors

Eigenvectors[m] gives a list of the eigenvectors of the square matrix m. 

Eigenvectors[{m,a}] gives the generalized eigenvectors of m with respect to a. 

Eigenvectors[m,k] gives the first k eigenvectors of m. 

Eigenvectors[{m,a},k] gives the first k generalized eigenvectors.

Element

Element[x,dom] or x∈dom asserts that x is an element of the domain dom. 

Element[x,reg] or x∈reg asserts that x is an element of the region reg.

Element[x1|x2|…,dom] asserts that all the xi are elements of dom. 

Element[patt,dom] asserts that any expression matching the pattern patt is an element of dom. 

ElementwiseLayer

ElementwiseLayer[f] represents a net layer that applies a unary function f to every element of the input array.

ElementwiseLayer["name"] applies the function specified by "name".

ElidedForms

ElidedForms is an option to TextString and related functions that specifies which expressions should be elided.

Eliminate

Eliminate[eqns,vars] eliminates variables between a set of simultaneous equations. 

Ellipsoid

Ellipsoid[p,{r1,…}] represents an axis-aligned ellipsoid centered at the point p and with semiaxes lengths ri.

Ellipsoid[p,Σ] represents an ellipsoid centered at p and weight matrix Σ.

EllipticE

EllipticE[m] gives the complete elliptic integral E(m). 

EllipticE[ϕ,m] gives the elliptic integral of the second kind E(ϕm). 

EllipticExp

EllipticExp[u,{a,b}] is the inverse for EllipticLog. It produces a list {x,y} such that u==EllipticLog[{x,y},{a,b}]. 

EllipticExpPrime

EllipticExpPrime[u,{a,b}] gives the derivative of EllipticExp[u,{a,b}] with respect to u.

EllipticF

EllipticF[ϕ,m] gives the elliptic integral of the first kind F(ϕm). 

EllipticFilterModel

EllipticFilterModel[n] designs a lowpass elliptic filter of order n.

EllipticFilterModel[{n,ωc}] uses the cutoff frequency ωc.

EllipticFilterModel[{"type",spec}] designs an elliptic filter of the specified type "type", using the spec.

EllipticFilterModel[{"type",spec},var] expresses the model in terms of the variable var.

EllipticK

EllipticK[m] gives the complete elliptic integral of the first kind K(m). 

EllipticLog

EllipticLog[{x,y},{a,b}] gives the generalized logarithm associated with the elliptic curve y2=x3+a x2+b x. 

EllipticNomeQ

EllipticNomeQ[m] gives the nome q corresponding to the parameter m in an elliptic function. 

EllipticPi

EllipticPi[n,m] gives the complete elliptic integral of the third kind Π(nm). 

EllipticPi[n,ϕ,m] gives the incomplete elliptic integral Π(n;ϕm). 

EllipticReducedHalfPeriods

EllipticReducedHalfPeriods[{u, v}] gives a reduced pair of half periods {w, w'} corresponding to the same lattice as that of {u, v}.

EllipticTheta

EllipticTheta[a,u,q] gives the theta function ϑa(u,q) (a=1,…,4).

EllipticTheta[a,q] gives the theta constant ϑa(q)ϑa(0,q).

EmbedCode

EmbedCode[obj] generates the code necessary to embed the object obj on a webpage.

EmbedCode[obj,"dest"] generates code for an external environment or language of type "dest".

EmbedCode[obj,"dest",dir] saves the generated code as files in the directory dir.

EmbedCode[obj,"dest",loc] saves the generated code as a file archive in the file location loc.

EmbeddedHTML

EmbeddedHTML["string"] is an object that formats as a web frame containing the HTML content "string". 

EmbeddedHTML[URL["url"]] formats as a rendering of the webpage corresponding to the specified URL.

EmbeddedHTML[CloudObject[…]] formats as a web rendering of the specified cloud object.

EmbeddedService

EmbeddedService[service] is an object that formats as a web frame containing content from the specified external service.

EmbeddedSQLEntityClass

EmbeddedSQLEntityClass[string,props] represents a verbatim SQL query to be interpreted as an entity class with properties given by props.

EmbeddedSQLEntityClass[template,props,args] represents an SQL query string template with arguments provided by args.

EmbeddedSQLExpression

EmbeddedSQLExpression[string] represents an SQL expression to be evaluated verbatim within an EntityFunction object.

EmbeddedSQLExpression[template,args] represents an SQL expression string template with arguments provided by args.

EmbeddingLayer

EmbeddingLayer[size,n] represents a trainable net layer that embeds integers between 1 and n into a continuous vector space of dimension size.

EmbeddingLayer[size] leaves the n to be inferred from context.

EmitSound

EmitSound[snd] emits the sound snd when evaluated. 

EmitSound[{snd1,snd2,…}] emits each of the sounds sndi in sequence. 

EmpiricalDistribution

EmpiricalDistribution[{x1,x2,…}] represents an empirical distribution based on the data values xi.

EmpiricalDistribution[{{x1,y1,…},{x2,y2,…},…}] represents a multivariate empirical distribution based on the data values {xi,yi,…}.

EmpiricalDistribution[{w1,w2,…}->{d1,d2,…}] represents an empirical distribution where data values di occur with weights wi.

EmptyGraphQ

EmptyGraphQ[g] yields True if g is an empty graph and False otherwise.

EmptyRegion

EmptyRegion[n] represents the empty subset of n. 

EmptySpaceF

EmptySpaceF[pdata,r] estimates the empty space function F(r) for point data pdata at radius r.

EmptySpaceF[pproc,r] computes F(r) for point process pproc.

EmptySpaceF[bdata,r] computes F(r) for binned data bdata. 

EmptySpaceF[pspec] generates the function F that can be applied repeatedly to different radii r.

Enabled

Enabled is an option for objects such as Slider that specifies whether the objects should be enabled for interactive manipulation. 

Enclose

Enclose[expr] attempts to evaluate expr and return the result, but stops if it catches an error and returns a failure object. 

Enclose[expr,f] applies f to any failure object generated.

Enclose[expr,"prop"] gives the property prop of any failure object generated. 

Enclose[expr,handler,form] only catches errors with explicitly specified tags matching form. 

Encode

Encode["source","dest"] writes an encoded version of the file source to the file dest. 

<<dest decodes the file before reading its contents. 

Encode["source","dest","key"] produces an encoded file that must be read in using Get["dest","key"]. 

Encrypt

Encrypt["password",expr] encrypts expr using the specified password, to give an encrypted object.

Encrypt[keyspec,expr] encrypts expr using the cryptographic key specification keyspec.

Encrypt[expr] interactively requests a password with which to encrypt expr.

EncryptedObject

EncryptedObject[assoc] represents encrypted data generated by Encrypt.

EncryptFile

EncryptFile["password",file] generates an encrypted version of a file, using the specified password.

EncryptFile["password",source,target] generates an encrypted version of source, putting the result in target.

EncryptFile[keyspec,source,…] encrypts using the cryptographic key specification keyspec.

End

End[] returns the present context, and reverts to the previous one. 

EndAdd

EndAdd[ ] returns the present context, and reverts to the previous one, prepending the present context to $ContextPath.

EndDialogPacket

EndDialogPacket[integer] is a WSTP packet indicating the end of the Dialog subsession referenced by integer.

EndOfBuffer

EndOfBuffer is a symbol that represents the end of currently available data in the buffer for a process or stream.

EndOfFile

EndOfFile is a symbol returned by Read when it reaches the end of a file. 

EndOfLine

EndOfLine represents the end of a line in a string for purposes of matching in StringExpression.

EndOfString

EndOfString represents the end of a string for purposes of matching in StringExpression.

EndPackage

EndPackage[] restores $Context and $ContextPath to their values before the preceding BeginPackage, and prepends the current context to the list $ContextPath. 

EngineeringForm

EngineeringForm[expr] prints with all real numbers in expr given in engineering notation. 

EngineeringForm[expr,n] prints with numbers given to n‐digit precision. 

EnterExpressionPacket

EnterExpressionPacket[expr] is a WSTP packet that requests the evaluation of expr.

EnterTextPacket

EnterTextPacket[string] is a WSTP packet that requests the parsing and evaluation of string as an expression.

Entity

Entity["type",name] represents an entity of the specified type, identified by name.

Entity[cspec,name] represents an entity from the computed class, specified by cspec. 

EntityClass

EntityClass[type,name] represents a class of entities of the specified type identified by name.

EntityClass[type,{property1->vspec1,property2->vspec2,…}] represents an implicitly defined entity class containing entities of the specified type for which the properties propertyi conform to the value selector vspeci.

EntityClass[cspec,psel] represents an entity class with members specified by cspec, selected by the property selector psel.

EntityClassList

EntityClassList["type"] gives a list of entity classes for the specified type of entity.

EntityCopies

EntityCopies[entity,n] represents n copies of entity.

EntityFunction

EntityFunction[x,body] is a function with a single formal parameter x, to be used in EntityValue and related functions.

EntityFunction[{x1,x2,…},body] is an EntityFunction with a list of formal parameters.

EntityGroup

EntityGroup[{entity1,entity2,…}] represents a group of entities.

EntityInstance

EntityInstance[entity,qual->val] represents an entity whose qualifier qual has value val.

EntityInstance[entity,{qual1->val1,qual2->val2,…}] represents an entity whose qualifiers quali have values vali.

EntityInstance[entity,quantity] represents an entity qualified by quantity.

EntityList

EntityList[class] gives a list of entities in the specified entity class. 

EntityList["type"] gives a list of entities of the specified type.

EntityList[class,simplify] gives a list of entities; simplify determines whether to reduce entities to the simplest possible type.

EntityPrefetch

EntityPrefetch["type"] fetches cacheable values associated with all entities of the specified type.

EntityPrefetch[EntityProperty["type","prop"]] fetches all values for the specified property.

EntityProperties

EntityProperties[type] lists properties associated with entity type type.

EntityProperty

EntityProperty[type,pname] represents a property identified by pname for use in EntityValue.

EntityProperty[class,pname] represents a property introduced by the computed entity class class.

EntityProperty[type,pname,{qual1->val1,qual2->val2,…}] represents a property modified by the qualifier rules quali->vali.

EntityPropertyClass

EntityPropertyClass[type,pcname] represents a class of properties identified by the name pcname.

EntityRegister

EntityRegister[estore] registers the entities in the entity store estore so that they can be accessed directly using Entity.

EntityStore

EntityStore["type"] represents an empty entity store for entities of type "type".

EntityStore["type"->data] represents an entity store for entities of type "type" with properties and values defined by data.

EntityStore[{tspec1,tspec2,…}] represents an entity store for entities of multiple types.

EntityStore[RelationalDatabase[…]] constructs an entity store from the schema of an external database.

EntityStore[{tspec1,tspec2,...},dbspec] constructs an entity store by mapping table names in the database specified by dbspec to types as specified by the tspeci.

EntityStores

EntityStores[] gives a list of all registered entity stores that are accessed when Entity is used.

EntityTypeName

EntityTypeName[entity] gives the name of the entity type of entity.

EntityTypeName[{entity1,…,entityn}] gives the name of the entity type for entity1 through entityn.

EntityUnregister

EntityUnregister["type"] unregisters all entities in the first entity store that defines entities of the specified type.

EntityUnregister[store] unregisters all entities in the specified entity store.

EntityValue

EntityValue[entity,property] gives the value of the specified property for the given entity.

EntityValue[{entity1,entity2,…},property] gives the list of values of the specified property for each of the entityi.

EntityValue[class,property] gives the list of values of the specified property for all entities in the specified class.

EntityValue[entity,{property1,property2,…}] gives the list of values of the propertyi for the specified entity.

EntityValue[ents,{property1,property2,…}] gives the list of values of the propertyi for each of the entities represented by ents.

Entropy

Entropy[list] gives the base  information entropy of the values in list.

Entropy[k,list] gives the base k information entropy.

Environment

Environment["var"] gives the value of an operating system environment variable. 

Epilog

Epilog is an option for graphics functions that gives a list of graphics primitives to be rendered after the main part of the graphics is rendered. 

EpilogFunction

EpilogFunction is an option for DocumentGenerator allowing arbitrary code to be executed after a document is generated.

Equal

lhs==rhs returns True if lhs and rhs are identical. 

EqualTilde

EqualTilde[x,y,…] displays as x≂y≂….

EqualTo

EqualTo[y] is an operator form that yields x==y when applied to an expression x. 

EquatedTo

EquatedTo is an option for Roots, which specifies an expression to use in place of the variable in the solution.

Equilibrium

Equilibrium[x,y,…] displays as x⇌y⇌….

EquirippleFilterKernel

EquirippleFilterKernel[{{{ωL1,ωR1},{ωL2,ωR2},…},{a1,a2,…}},n] creates a finite impulse response (FIR) filter kernel of length n with an equiripple amplitude response, given the specified left and right band edge frequencies {ωLi,ωRi} and amplitudes ai.

EquirippleFilterKernel[{{{ωL1,ωR1},{ωL2,ωR2},…},{a1,a2,…},{w1,…}},n] uses relative weights wi for each frequency band.

EquirippleFilterKernel[{"type",{{{ωL1,ωR1},…},…}},n] creates a filter of the specified "type".

Equivalent

Equivalent[e1,e2,…] represents the logical equivalence e1⇔e2⇔…, giving True when all of the ei are the same.

Erf

Erf[z] gives the error function erf(z). 

Erf[z0,z1] gives the generalized error function erf(z1)-erf(z0). 

Erfc

Erfc[z] gives the complementary error function erfc(z). 

Erfi

Erfi[z] gives the imaginary error function erf(iz)/i. 

ErlangB

ErlangB[c,a] computes the Erlang B loss probability for an M/M/c/c queue.

ErlangC

ErlangC[c,a] computes the Erlang C probability for nonzero waiting time in an M/M/c queue.

ErlangDistribution

ErlangDistribution[k,λ] represents the Erlang distribution with shape parameter k and rate λ.

Erosion

Erosion[image,ker] gives the morphological erosion of image with respect to the structuring element ker.

Erosion[image,r] gives the erosion with respect to a range-r square.

Erosion[data,…] applies erosion to an array of data.

EscapeRadius

EscapeRadius is an option to MandelbrotSetPlot that specifies the criterion to use to decide that a point is not in the Mandelbrot set.

EstimatedBackground

EstimatedBackground[data] estimates the background of data.

EstimatedBackground[data,σ] tries to preserve peaks up to scale σ.

EstimatedDistribution

EstimatedDistribution[data,dist] estimates the parametric distribution dist from data.

EstimatedDistribution[data,dist,{{p,p0},{q,q0},…}] estimates the parameters p, q, … with starting values p0, q0, ….

EstimatedDistribution[data,dist,idist] estimates distribution dist with starting values taken from the instantiated distribution idist.

EstimatedPointProcess

EstimatedPointProcess[pdata,pproc] estimates the parametric point process pproc from point data pdata.

EstimatedPointProcess[pdata,pproc,{{p,p0},{q,q0},…}] estimates the parameters p, q, … with starting values p0, q0, ….

EstimatedProcess

EstimatedProcess[data,proc] estimates the parametric process proc from data.

EstimatedProcess[data,proc,{{p,p0},{q,q0},…}] estimates the parameters p, q, … with starting values p0, q0, ….

EstimatedProcess[data,proc,iproc] estimates process proc with starting values taken from the instantiated process iproc.

EstimatedVariogramModel

EstimatedVariogramModel[{loc1->val1,loc2->val2,…}] estimates the best variogram function from values vali given at locations loci.

EstimatedVariogramModel[{loc1,loc2,…}->{val1,val2,…}] generates the same result. 

EstimatedVariogramModel[…,"model"] estimates the best parameters of the variogram function specified by "model". 

EstimatedVariogramModel[…,{"model",params}] estimates the non-numeric parameters in params.

EstimatorGains

EstimatorGains[ssm,{p1,p2,…,pn}] gives the estimator gain matrix for the StateSpaceModel ssm, such that the poles of the estimator are pi.

EstimatorGains[{ssm,{out1,…}},…] specifies the measured outputs outi to use.

EstimatorRegulator

EstimatorRegulator[sspec,{l,κ}] gives the output feedback controller with estimator and regulator gains l and κ for the system specification sspec.

EstimatorRegulator[…,"prop"] gives the value of the property "prop".

EuclideanDistance

EuclideanDistance[u,v] gives the Euclidean distance between vectors u and v.

EulerAngles

EulerAngles[r] gives Euler angles {α,β,γ} corresponding to the rotation matrix r.

EulerAngles[r,{a,b,c}] gives Euler angles {α,β,γ} with rotation order {a,b,c}. 

EulerCharacteristic

EulerCharacteristic[poly] gives the Euler characteristic of a poly.

EulerE

EulerE[n] gives the Euler number En. 

EulerE[n,x] gives the Euler polynomial En(x). 

EulerGamma

EulerGamma is Euler’s constant γ, with numerical value ≃0.577216. 

EulerianGraphQ

EulerianGraphQ[g] yields True if the graph g is Eulerian, and False otherwise.

EulerMatrix

EulerMatrix[{α,β,γ}] gives the Euler 3D rotation matrix formed by rotating by α around the current z axis, then by β around the current y axis, and then by γ around the current z axis. 

EulerMatrix[{α,β,γ},{a,b,c}] gives the Euler 3D rotation matrix corresponding, first rotating by α around the current a axis, then by β around the current b axis, and finally by γ around the current c axis.

EulerPhi

EulerPhi[n] gives the Euler totient function ϕ(n). 

Evaluate

Evaluate[expr] causes expr to be evaluated even if it appears as the argument of a function whose attributes specify that it should be held unevaluated. 

EvaluatePacket

EvaluatePacket[expr] is a WSTP packet requesting evaluation of expr.

EvaluateScheduledTask

EvaluateScheduledTask[expr] triggers immediate local execution of the specified task object.

EvaluationData

EvaluationData[expr] gives an association containing the result of evaluating expr and metadata about the process of doing so.

EvaluationEnvironment

EvaluationEnvironment is an option for functions such as InitializationValue and InitializationObjects that specifies the environment in which an initialization is intended to be used.

EvaluationMonitor

EvaluationMonitor is an option for various numerical computation and plotting functions that gives an expression to evaluate whenever functions derived from the input are evaluated numerically. 

EvaluationObject

EvaluationObject[expr,…] represents an expression submitted for evaluation on any available parallel kernel.

EvenQ

EvenQ[expr] gives True if expr is an even integer, and False otherwise. 

EventSeries

EventSeries[{{t1,v1},{t2,v2}…}] represents a series of events given as time-value pairs {ti,vi}.

EventSeries[{v1,v2,…},tspec] represents a series of events with values vi at times specified by tspec.

ExactBlackmanWindow

ExactBlackmanWindow[x] represents an exact Blackman window function of x.

ExactNumberQ

ExactNumberQ[expr] returns True if expr is an exact real or complex number, and returns False otherwise.

ExactRootIsolation

ExactRootIsolation is an option for Root, which specifies whether exact isolating intervals rather than numeric approximations should be used to identify algebraic numbers.

ExampleData

ExampleData["type"] gives a list of names of examples of the specified type.

ExampleData[{"type","name"}] gives the default form of the named example of the specified type.

ExampleData[{"type","name"},"elem"] gives the specified element or property of an example.

Except

Except[c] is a pattern object which represents any expression except one that matches c. 

Except[c,p] represents any expression that matches p but not c. 

ExcludedContexts

ExcludedContexts is an option for FullDefinition, Manipulate and related symbols that gives contexts whose symbols will not have the definitions recursively saved.

ExcludedForms

ExcludedForms is an option that gives a list of patterns for expressions that should be excluded from an operation performed by a particular function. 

ExcludedLines

ExcludedLines is an option for SemanticImport and related functions that specifies which lines should be ignored for further processing.

ExcludedPhysicalQuantities

ExcludedPhysicalQuantities is an option for FormulaLookup that specifies physical quantities that should be not used by the formulas returned.

ExcludePods

ExcludePods is an option to WolframAlpha that specifies pod IDs to exclude from the results.

Exclusions

Exclusions is an option that specifies where to exclude in regions used by functions like Plot, Plot3D, and NIntegrate.

ExclusionsStyle

ExclusionsStyle is an option to plotting functions that specifies how to render subregions excluded according to Exclusions. 

Exists

Exists[x,expr] represents the statement that there exists a value of x for which expr is True. 

Exists[x,cond,expr] states that there exists an x satisfying the condition cond for which expr is True. 

Exists[{x1,x2,…},expr] states that there exist values for all the xi for which expr is True. 

Exit

Exit[] terminates a Wolfram Language kernel session. 

ExoplanetData

ExoplanetData[entity,property] gives the value of the specified property for the exoplanet entity.

ExoplanetData[{entity1,entity2,…},property] gives a list of property values for the specified exoplanet entities.

ExoplanetData[entity,property,annotation] gives the specified annotation associated with the given property.

Exp

Exp[z] gives the exponential of z. 

Expand

Expand[expr] expands out products and positive integer powers in expr. 

Expand[expr,patt] leaves unexpanded any parts of expr that are free of the pattern patt.

ExpandAll

ExpandAll[expr] expands out all products and integer powers in any part of expr. 

ExpandAll[expr,patt] avoids expanding parts of expr that do not contain terms matching the pattern patt. 

ExpandDenominator

ExpandDenominator[expr] expands out products and powers that appear as denominators in expr. 

ExpandFileName

ExpandFileName["name"] textually expands name to have the form of an absolute file name for your operating system.

ExpandNumerator

ExpandNumerator[expr] expands out products and powers that appear in the numerator of expr. 

Expectation

Expectation[expr,xdist] gives the expectation of expr under the assumption that x follows the probability distribution dist. 

Expectation[expr,xdata] gives the expectation of expr under the assumption that x follows the probability distribution given by data.

Expectation[expr,{x1,x2,…}dist] gives the expectation of expr under the assumption that {x1,x2,…} follows the multivariate distribution dist. 

Expectation[expr,{x1dist1,x2dist2,…}] gives the expectation of expr under the assumption that x1, x2, … are independent and follow the distributions dist1, dist2, …. 

Expectation[exprpred,…] gives the conditional expectation of expr given pred.

ExpectedValue

ExpectedValue[f,list] gives the expected value of the pure function f with respect to the values in list. 

ExpectedValue[f,list,x] gives the expected value of the function f of x with respect to the values of list.

ExpectedValue[f,dist] gives the expected value of the pure function f with respect to the symbolic distribution dist.

ExpectedValue[f,dist,x] gives the expected value of the function f of x with respect to the symbolic distribution dist.

ExpGammaDistribution

ExpGammaDistribution[κ,θ,μ] represents an exp-gamma distribution with shape parameter κ, scale parameter θ, and location parameter μ.

ExpIntegralE

ExpIntegralE[n,z] gives the exponential integral function En(z).

Offload

Use Offload[expr_] to keep expr from evaluation on Kernel

ExpIntegralEi

ExpIntegralEi[z] gives the exponential integral function Ei(z). 

ExpirationDate

ExpirationDate is an option for various functions that specifies when a persistent value should be treated as expired.

Exponent

Exponent[expr,form] gives the maximum power with which form appears in the expanded form of expr. 

Exponent[expr,form,h] applies h to the set of exponents with which form appears in expr. 

ExponentFunction

ExponentFunction is an option for NumberForm and related functions that determines the exponent to use in printing approximate real numbers. 

ExponentialDistribution

ExponentialDistribution[λ] represents an exponential distribution with scale inversely proportional to parameter λ.

ExponentialFamily

ExponentialFamily is an option for GeneralizedLinearModelFit that specifies the exponential family for the model.

ExponentialMovingAverage

ExponentialMovingAverage[list,α] gives the exponential moving average of list with smoothing constant α.

ExponentialPowerDistribution

ExponentialPowerDistribution[κ,μ,σ] represents an exponential power distribution with shape parameter κ, location parameter μ, and scale parameter σ.

ExponentialPowerDistribution[κ] represents an exponential power distribution with location parameter 0 and scale parameter 1.

ExponentStep

ExponentStep is an option for NumberForm and related functions that determines in what steps exponents are taken to increase when scientific notation is used.

Export

Export["dest.ext",expr] exports data to a file, converting it to the format corresponding to the file extension ext. 

Export[dest,expr,"fmt"] exports data in the specified format "fmt".

Export[dest,exprs,elements] exports data by treating exprs as elements.

Export[dest,exprs,elements,options] uses the specified options.

ExportByteArray

ExportByteArray[expr,"format"] generates a ByteArray object corresponding to expr exported in the specified format. 

ExportByteArray[exprs,elems] generates a ByteArray object by treating exprs as elements specified by elems.

ExportForm

ExportForm[expr,"fmt"] specifies that expr should be exported in the specified format in functions like CloudDeploy and in external results from APIFunction and FormFunction.

ExportForm[expr,{"fmt","type"}] specifies that when expr is exported, it should be tagged as having the specified MIME type.

ExportString

ExportString[expr,"format"] generates a string corresponding to expr exported in the specified format. 

ExportString[rules,{"format","Rules"}] gives explicit rules for different elements of the data to be exported. 

ExportString[exprs,elems] generates a string by treating exprs as elements specified by elems.

Expression

Expression is a symbol that represents an ordinary Wolfram Language expression in Read and related functions. 

ExpressionGraph

ExpressionGraph[expr] gives the tree graph with different levels at different depths. 

ExpressionGraph[expr,n] gives the tree graph only down to level n.

ExpressionGraph[expr,n,form] gives a tree graph in which subexpressions that match form are leaves.

ExpressionTree

ExpressionTree[expr] gives a Tree object from the structure of the expression expr.

ExpressionTree[expr,struct] gives a Tree object from the expression expr with data and subtrees as specified by struct.

ExpToTrig

ExpToTrig[expr] converts exponentials in expr to trigonometric functions. 

ExtendedEntityClass

ExtendedEntityClass[class,"name"->f] represents an entity class derived from class by adding a new computed property "name" whose value for each entity is obtained by applying the entity function f.

ExtendedEntityClass[class,{name1->f1,name2->f2,…}] adds the properties namei defined by the functions fi.

ExtendedGCD

ExtendedGCD[n1,n2,…] gives the extended greatest common divisor of the integers ni. 

Extension

Extension is an option for various polynomial and algebraic functions that specifies generators for the algebraic number field to be used. 

ExtentElementFunction

ExtentElementFunction is an option to DiscretePlot and DiscretePlot3D that gives a function to use to generate the primitives for rendering each extent element. 

ExtentMarkers

ExtentMarkers is an option to DiscretePlot and DiscretePlot3D that specifies markers to draw at extent boundaries. 

ExtentSize

ExtentSize is an option to DiscretePlot and DiscretePlot3D that specifies how far to extend out from each plot point. 

ExternalBundle

ExternalBundle[{name1->obj1,name2->obj2,…}] represents a bundle of resources to be externally deployed as named URLs, functions, etc. 

ExternalBundle[{name11->{name1->…,…},…}] represents a nested bundle of resources.

ExternalDataCharacterEncoding

ExternalDataCharacterEncoding is a global option that specifies the character encoding used in reading and writing plain text data outside of the Wolfram System.

ExternalEvaluate

ExternalEvaluate["sys","cmd"] evaluates the command cmd in the external evaluator sys, returning an expression corresponding to the output.

ExternalEvaluate[{"sys",opts},"cmd"] uses the options opts for the external evaluator.

ExternalEvaluate[assoc,"cmd"] evaluates cmd using the external evaluator specified by assoc.

ExternalEvaluate[session,"cmd"] evaluates cmd in the specified running ExternalSessionObject.

ExternalEvaluate[sys->"type",…] returns output converted to the specified type. 

ExternalEvaluate[spec,obj] evaluates the content of the specified ExternalObject, ExternalOperation, File, URL or CloudObject.

ExternalEvaluate[spec,assoc] evaluates the command specified by assoc.

ExternalEvaluate[spec,{cmd1,cmd2,…}] evaluates the list of commands cmdi.

ExternalEvaluate[DatabaseReference[ref],"cmd"] evaluates cmd using the database specified by ref.

ExternalEvaluate[spec] represents an operator form of ExternalEvaluate that can be applied to a command or object.

ExternalFunction

ExternalFunction[sys,"f"] represents an external function named "f" defined in the external evaluator sys.

ExternalFunction[session,"f"] represents an external function "f" in the specified ExternalSessionObject.

ExternalFunction[sys,"code"] represents an external function defined by the code fragment "code".

ExternalFunction[obj,"method"] represents a method bound to the ExternalObject.

ExternalIdentifier

ExternalIdentifier["type",id] represents a resource identified by id in the external identifier system "type".

ExternalIdentifier["type",id,meta] includes the metadata given by the association meta to this instance of the external identifier object.

ExternalObject

ExternalObject[…] represents an external object bound to an ExternalSessionObject.

ExternalOptions

ExternalOptions is an option for EmbedCode and related functions that gives options specific to the external environment or language used.

ExternalSessionObject

ExternalSessionObject[…] represents an external session started by StartExternalSession for use with ExternalEvaluate.

ExternalSessions

ExternalSessions[] gives the list of currently active external evaluator sessions.

ExternalSessions[sys] gives the list of sessions associated with the system sys.

ExternalStorageBase

ExternalStorageBase is an option for various external storage functions that specifies which external storage service to use.

ExternalStorageDownload

ExternalStorageDownload[location] downloads content from the specified location.

ExternalStorageDownload[location,dest] downloads content from the specified location to a local destination file or directory dest.

ExternalStorageDownload[location->dest] downloads content from the specified locations to a local destination file or directory dest.

ExternalStorageDownload[{location1,location2,…},dest] downloads content from the specified locations to local destination dest.

ExternalStorageDownload[{location1,location2,…}->dest] downloads content from the specified locations to local destination dest.

ExternalStorageDownload[{location1->dest1,location2->dest2,…}] downloads content from the specified locations to local destinations.

ExternalStorageGet

ExternalStorageGet[ExternalStorageObject[…]] reads in an expression stored at an external storage specified by the ExternalStorageObject.

ExternalStorageGet[location] reads in an expression stored at location in an external storage specified by $ExternalStorageBase.

ExternalStorageObject

ExternalStorageObject[location] represents a file stored in an external location.

ExternalStorageObject[assoc] represents a file stored in an external service specified by the components of the association assoc.

ExternalStorageObject[location,assoc] represents a file stored in an external location with additional elements given by assoc.

ExternalStoragePut

ExternalStoragePut[expr] writes expr to an external storage specified by $ExternalStorageBase.

ExternalStoragePut[expr,path] writes expr to a specific path in an external storage specified by $ExternalStorageBase.

ExternalStoragePut[expr,ExternalStorageObject[...]] writes expr to the service and path represented by an ExternalStorageObject. 

ExternalStorageUpload

ExternalStorageUpload[file] uploads file to an external storage specified by $ExternalStorageBase.

ExternalStorageUpload[file,dest] uploads file to a specific destination dest for external storage services that support it.

ExternalStorageUpload[file->dest] uploads file to a specific destination dest for external storage services that support it. 

ExternalStorageUpload[{file1,file2,…},dest] uploads a list of files to a specific destination dest for external storage services that support it.

ExternalStorageUpload[{file1,file2,…}->dest] uploads a list of files to a specific destination dest for external storage services that support it.

ExternalStorageUpload[{file1->dest1,file2->dest2,…}] uploads a list of files to specific destinations for external storage services that support it.

ExternalTypeSignature

ExternalTypeSignature is an option for EmbedCode that gives rules specifying the mapping to external types in an embedded code.

ExternalValue

ExternalValue[sys,"sym"] gives the value of "sym" in external evaluator sys. 

ExternalValue[session,"sym"] gives the value of "sym" in the specified external session.

Extract

Extract[expr,pos] extracts the part of expr at the position specified by pos. 

Extract[expr,{pos1,pos2,…}] extracts a list of parts of expr. 

Extract[expr,pos,h] extracts parts of expr, wrapping each of them with head h before evaluation. 

Extract[pos] represents an operator form of Extract that can be applied to an expression.

ExtractArchive

ExtractArchive[source] expands an archive file, saving its content into the current directory.

ExtractArchive[source,dir] saves the content of an archive file into directory dir.

ExtractArchive[source,dir,pattern] extracts only files whose names match pattern.

ExtractLayer

ExtractLayer[] represents a net layer that takes an array and a position specification as inputs and extracts the specified parts from the array.

ExtractPacletArchive

ExtractPacletArchive[file] extracts the contents of the paclet archive file into the directory in which file resides.

ExtractPacletArchive[file,destdir] extracts the contents of the paclet archive file into destdir.

ExtremeValueDistribution

ExtremeValueDistribution[α,β] represents an extreme value distribution with location parameter α and scale parameter β.

ExtremeValueDistribution[] represents an extreme value distribution with location parameter 0 and scale parameter 1.

FaceAlign

FaceAlign[image] attempts to find faces in image and align them.

FaceAlign[image,fref] gives aligned faces according to the face reference fref. 

FaceAlign[image,fref,size] gives aligned faces of the specified size.

FaceAlign[{image1,image2,…},…] gives a list of aligned faces for all imagei.

FaceForm

FaceForm[g] is a graphics directive which specifies that faces of polygons and other filled graphics objects are to be drawn using the graphics directive or list of directives g. 

FaceForm[g,gback] specifies that the front faces of three-dimensional polygons should be drawn with directives g, and the backs with directives gback. 

FaceGrids

FaceGrids is an option for three-dimensional graphics functions that specifies grid lines to draw on the faces of the bounding box. 

FaceGridsStyle

FaceGridsStyle is an option for 3D graphics functions that specifies how face grids should be rendered.

FaceRecognize

FaceRecognize[{example1->name1,example2->name2,…}] generates a ClassifierFunction[…] based on the face examples and names given.

FaceRecognize[{example1,example2,…}->{name1,name2,…}] also generates a ClassifierFunction[…] based on the examples and names given.

FaceRecognize[<|name1->{example11,…},name2->{example21,…},…|>] uses an association of names with their examples.

FaceRecognize[training,image] attempts to find faces present in an image and classify them with the given training set. 

FaceRecognize[training,image,prop] returns the specified property prop.

FacialFeatures

FacialFeatures[image] returns a minimal summary of facial features for all detected faces in image.

FacialFeatures[image,features] returns the specified facial features.

FacialFeatures[video,…] finds faces in frames of video.

Factor

Factor[poly] factors a polynomial over the integers. 

Factor[poly,Modulus->p] factors a polynomial modulo the prime p. 

Factor[poly,Extension->{a1,a2,…}] factors a polynomial allowing coefficients that are rational combinations of the algebraic numbers ai. 

Factorial

n! gives the factorial of n. 

Factorial2

n!! gives the double factorial of n. 

FactorialMoment

FactorialMoment[data,r] gives the order r factorial moment μ&_r of data.

FactorialMoment[data,{r1,…,rm}] gives the order {r1,…,rm} multivariate factorial moment μ&_r1, …, rm of data.

FactorialMoment[dist,…] gives the factorial moment of the distribution dist.

FactorialMoment[r] represents the order r formal factorial moment. 

FactorialMomentGeneratingFunction

FactorialMomentGeneratingFunction[dist,t] gives the factorial moment-generating function for the distribution dist as a function of the variable t. 

FactorialMomentGeneratingFunction[dist,{t1,t2,…}] gives the factorial moment-generating function for the multivariate distribution dist as a function of the variables t1, t2, …. 

FactorialPower

FactorialPower[x,n] gives the factorial power x(n). 

FactorialPower[x,n,h] gives the step-h factorial power x(n,h).

FactorInteger

FactorInteger[n] gives a list of the prime factors of the integer n, together with their exponents. 

FactorInteger[n,k] does partial factorization, pulling out at most k distinct factors.

FactorList

FactorList[poly] gives a list of the factors of a polynomial, together with their exponents. 

FactorSquareFree

FactorSquareFree[poly] pulls out any multiple factors in a polynomial. 

FactorSquareFreeList

FactorSquareFreeList[poly] gives a list of square‐free factors of a polynomial, together with their exponents. 

FactorTerms

FactorTerms[poly] pulls out any overall numerical factor in poly. 

FactorTerms[poly,x] pulls out any overall factor in poly that does not depend on x. 

FactorTerms[poly,{x1,x2,…}] pulls out any overall factor in poly that does not depend on any of the xi. 

FactorTermsList

FactorTermsList[poly] gives a list in which the first element is the overall numerical factor in poly, and the second element is the polynomial with the overall factor removed.

FactorTermsList[poly,{x1,x2,…}] gives a list of factors of poly. The first element in the list is the overall numerical factor. The second element is a factor that does not depend on any of the xi. Subsequent elements are factors which depend on progressively more of the xi. 

Failure

Failure["tag",assoc] represents a failure of a type indicated by tag, with details given by the association assoc.

FailureAction

FailureAction is an option to Query and related functions that determines what should happen when a failure or message is generated.

FailureDistribution

FailureDistribution[bexpr,{{x1,dist1},{x2,dist2},…}] represents the failure distribution for a system with events xi having reliability distribution disti where the top event occurs when the Boolean expression bexpr is True and event xi has occurred when xi is True.

FailureQ

FailureQ[expr] gives True if expr has head Failure or is equal to $Failed or $Aborted.

False

False is the symbol for the Boolean value false. 

FareySequence

FareySequence[n] generates the Farey sequence of order n.

FareySequence[n,k] gives the kth element of the Farey sequence of order n.

FeatureDistance

FeatureDistance[example1,example2,extractor] gives the distance between example1 and example2 in the feature space defined by extractor.

FeatureDistance[extractor] represents an operator form of FeatureDistance that can be applied to a pair of examples.

FeatureExtract

FeatureExtract[{example1,example2,…}] extracts features for each of the examplei using a feature extractor trained on all the examplei.

FeatureExtract[examples,extractor] extracts features using the specified feature extractor method.

FeatureExtract[examples,{extractor1,extractor2,…}] extracts features by applying the extractori in sequence.

FeatureExtract[examples,spec->ext] uses the extractor methods specified by ext on parts of examples specified by spec. 

FeatureExtract[examples,{spec1->ext1,spec2->ext2,…}] uses the extractor methods exti on parts of examples specified by the speci.

FeatureExtraction

FeatureExtraction[{example1,example2,…}] generates a FeatureExtractorFunction[…] trained from the examples given.

FeatureExtraction[examples,extractor] uses the specified feature extractor method.

FeatureExtraction[examples,{extractor1,extractor2,…}] applies the extractori in sequence to generate a feature extractor.

FeatureExtraction[examples,spec->ext] uses the extractor methods specified by ext on parts of examples specified by spec. 

FeatureExtraction[examples,{spec1->ext1,spec2->ext2,…}] uses the extractor methods exti on parts of examples specified by the speci.

FeatureExtraction[examples,extractor,props] gives the feature extraction properties specified by props.

FeatureExtractor

FeatureExtractor is an option for functions such as Classify that specifies how features should be extracted.

FeatureExtractorFunction

FeatureExtractorFunction[…] represents a feature extractor function generated by FeatureExtraction.

FeatureNames

FeatureNames is an option for machine learning functions such as Classify or Predict that specifies names to use for elements of input data given.

FeatureNearest

FeatureNearest[{elem1,elem2,…},x] gives the list of elemi to which x is nearest in a computed feature space.

FeatureNearest[{elem1->v1,elem2->v2,…},x] gives the vi corresponding to the elemi to which x is nearest.

FeatureNearest[{elem1,elem2,…}->{v1,v2,…},x] gives the same result.

FeatureNearest[{elem1,elem2,…}->prop,x] gives the property prop for the elemi to which x is nearest.

FeatureNearest[data,{x1,x2,…}] effectively gives {FeatureNearest[data,x1],FeatureNearest[data,x2],…}.

FeatureNearest[data,x,n] gives the n nearest elemi to x.

FeatureNearest[data] generates a NearestFunction[…] that can be applied repeatedly to different x.

FeatureSpacePlot

FeatureSpacePlot[{example1,example2,…}] plots features extracted from the examplei as a scatter plot.

FeatureSpacePlot3D

FeatureSpacePlot3D[{example1,example2,…}] plots features extracted from the examplei as a scatter 3D plot.

FeatureTypes

FeatureTypes is an option for machine learning functions such as Classify or Predict that specifies what feature types to assume for elements of input data given.

FeedbackLinearize

FeedbackLinearize[asys] input-output linearizes the AffineStateSpaceModel asys by state transformation and feedback.

FeedbackLinearize[asys,{z,v}] specifies the new states z and the new control inputs v.

FeedbackLinearize[asys,{z,v},"prop"] computes the property "prop".

FeedbackSector

FeedbackSector is an option to NyquistPlot that specifies the sector limits of the nonlinearity in the feedback. 

FeedbackSectorStyle

FeedbackSectorStyle is an option to NyquistPlot that specifies the style in which graphics of FeedbackSector should be drawn.

FeedbackType

FeedbackType is an option for some control system functions that specifies the feedback type.

FetalGrowthData

FetalGrowthData[age] returns the values for all properties of fetal development for the specified age of the fetus.

FetalGrowthData[age,property] returns the value for a property of fetal development for the specified age.

FetalGrowthData[age,index] returns the values for all properties of fetal development at the specified age and percentile.

FetalGrowthData[age,property,index] returns the value for a property at the specified age and percentile.

Fibonacci

Fibonacci[n] gives the Fibonacci number Fn. 

Fibonacci[n,x] gives the Fibonacci polynomial Fn(x). 

Fibonorial

Fibonorial[n] gives the fibonorial n!F.

FieldCompletionFunction

FieldCompletionFunction is an option for InputField that specifies a function to apply to the input field's contents to generate a list of completions.

FieldHint

FieldHint is an option for InputField that specifies contents to display when the input field is empty.

FieldHintStyle

FieldHintStyle is an option for InputField that specifies the style to use for displaying the field hint.

FieldMasked

FieldMasked is an option to InputField that determines whether to mask user input.

FieldSize

FieldSize is an option for InputField, PopupMenu, and related functions that specifies the size of the field allowed for input or contents. 

File

File["path"] is a symbolic representation of a location in the local file system. 

FileBaseName

FileBaseName["file"] gives the base name for a file without its extension.

FileByteCount

FileByteCount[file] gives the number of bytes in a file. 

FileConvert

FileConvert[source->"dest.ext"] converts the contents of source to the format defined by the extension ext and writes the result to the file dest.ext. 

FileConvert[source,"format"] writes the result to the filename defined by source, but with an extension defined by the specified format.

FileConvert[source->"dest.ext",format1->format2] takes the contents of source to be in the specified format "format1".

FileDate

FileDate["file"] gives the date and time at which a file was last modified. 

FileDate["file","type"] gives information on the specified type of date associated with a file.

FileExistsQ

FileExistsQ["name"] gives True if the file with the specified name exists, and gives False otherwise.

FileExtension

FileExtension["file"] gives the file extension for a file name.

FileFormat

FileFormat[source] attempts to determine what Import format could be used to import the file corresponding to source. 

FileFormat[source,{fmt1,fmt2,…}] returns the first "fmti" that can be used to import source.

FileFormatProperties

FileFormatProperties["fmt"] returns an association of properties for the specified format "fmt".

FileFormatProperties["fmt","prop"] returns the property "prop" for the format "fmt".

FileFormatProperties["fmt",{prop1,prop2,…}] returns multiple properties.

FileFormatQ

FileFormatQ[source,"fmt"] gives True if the file corresponding to source might be imported as format "fmt" and gives False otherwise.

FileFormatQ[source,{fmt1,fmt2,…}] gives True if source might be imported as one of "fmti".

FileHash

FileHash[file] gives an integer hash code for the contents of the specified file.

FileHash[file,"type"] gives an integer hash of the specified type.

FileHash[file,"type","format"] gives a hash code in the specified format.

FileHash[{file,range},…] gives the hash code for the specified range of bytes.

FileHash[{filespec1,filespec2,…},…] gives the hash codes for a list of files.

FileNameDepth

FileNameDepth["name"] gives the number of path elements in the file name "file".

FileNameDialogSettings

FileNameDialogSettings is a global option that specifies settings for the Insert File Path dialog box.

FileNameDrop

FileNameDrop["name",n] drops the first n path elements in the file name "name".

FileNameDrop["name",-n] drops the last n path elements in the file name "name".

FileNameDrop["name",{m,n}] drops elements m through n in the file name "name".

FileNameDrop["name"] drops the last path element in the file name "name".

FileNameForms

FileNameForms is an option that specifies the pattern for file names to be selected by a function.

FileNameJoin

FileNameJoin[{name1,name2,…}] joins the namei together into a file name suitable for your current operating system. 

FileNameJoin[{CloudObject[…],name2,…}] joins the namei to the path in the specified cloud object. 

FileNameJoin[{LocalObject[…],name2,…}] joins the namei to the path in the specified local object.

FileNameJoin[name1,name2, …] is equivalent to FileNameJoin[{name1,name2,…}].

FileNames

FileNames[] lists all files in the current working directory. 

FileNames[form] lists all files in the current working directory whose names match the string pattern form. 

FileNames[{form1,form2,…}] lists all files whose names match any of the formi. 

FileNames[All,dir] lists all files in the directory dir.

FileNames[forms,{dir1,dir2,…}] lists files with names matching forms in any of the directories diri. 

FileNames[forms,dirs,n] includes files that are in subdirectories up to n levels down. 

FileNameSplit

FileNameSplit["name"] splits a file name into a list of parts.

FileNameTake

FileNameTake["name"] gives the last path element in the file name "name".

FileNameTake["name",n] gives the first n path elements in the file name "name".

FileNameTake["name",-n] gives the last n path elements in the file name "name".

FileNameTake["name",{m,n}] gives elements m through n in the file name "name".

FileNameToFormatList

FileNameToFormatList[] returns lists of file formats corresponding to all registered file name patterns.

FileNameToFormatList["file"] returns a list of file formats that matches the file name "file".

FilePrint

FilePrint["file"] prints out the raw textual contents of file.

FilePrint["file",n] prints out the first n raw textual lines of file.

FilePrint["file",-n] prints out the last n raw textual lines of file.

FilePrint["file",m;;n] prints out lines m through n of file.

FilePrint["file",m;;n;;s] prints out lines m through n of file in steps of s.

FileSize

FileSize[file] gives the size of a file as a quantity.

FileTemplate

FileTemplate["file"] yields a TemplateObject expression that represents a file template to be applied using functions like TemplateApply.

FileTemplate[src] uses File[…], URL[…], or CloudObject[…] as the specification for the file location.

FileTemplate[form,args] yields a TemplateObject with arguments, suitable for cloud deployment or other evaluation.

FileTemplateApply

FileTemplateApply[template] applies a template, evaluating all template elements it contains, and then writes the result to a temporary file, whose name is returned.

FileTemplateApply[template,args] applies a template, using args to fill its slots, and then writes the result to a temporary file.

FileTemplateApply[template,output] applies a template, writing the results to the file represented by output.

FileTemplateApply[template,args,output] applies a template, using args to fill its slots, and then writes the result to the file represented by output.

FileType

FileType["file"] gives the type of a file, typically File, Directory, or None. 

FilledCurve

FilledCurve[{segment1,segment2,…}] represents a filled curve consisting of segment1 followed by segment2 etc. 

FilledCurve[{component1,component2,…}] represents a list of separate filled component curves component1, component2, etc. 

FilledTorus

FilledTorus[{x,y,z},{rinner,router}] represents a filled torus centered at {x,y,z} with inner radius rinner and outer radius router.

Filling

Filling is an option for ListPlot, Plot, Plot3D, and related functions that specifies what filling to add under points, curves, and surfaces. 

FillingStyle

FillingStyle is an option for ListPlot, Plot, Plot3D, and related functions that specifies the default style of filling to be used. 

FillingTransform

FillingTransform[image] gives a version of image with all extended minima filled.

FillingTransform[image,marker] fills extended minima in regions where at least one corresponding element of marker is nonzero.

FillingTransform[image,h] fills only extended minima of depth h or less.

FilteredEntityClass

FilteredEntityClass[class,f] represents a class of entities where only entities for which the EntityFunction object f yields True are kept.

FilteredEntityClass[class,prop] represents a class of entities where only entities for which the property prop is True are kept.

FilterRules

FilterRules[rules,patt] filters the list rules by picking out only those rules whose left-hand sides match patt.

FilterRules[rules,{patt1,patt2,…}] picks out rules whose left-hand sides match any of the patti.

FinancialBond

FinancialBond[params,ambientparams] gives the value of a financial bond instrument.

FinancialBond[params,ambientparams,prop] computes the specified property prop.

FinancialData

FinancialData["name"] gives the last known price or value for the financial entity specified by "name".

FinancialData["name",start] gives a list of dates and daily closing values for "name" from start until the current date.

FinancialData["name",{start,end}] gives a list of dates and daily closing values for dates from start to end.

FinancialData["name",{start,end,period}] gives a list of dates and prices for the specified periods lying between start and end.

FinancialData["name","prop"] gives the value of the specified property for the financial entity "name". 

FinancialData["name","prop",{start,end,…}] gives a list of dates and values of a property for a sequence of dates or periods. 

FinancialDerivative

FinancialDerivative[instrument,params,ambientparams] gives the value of the specified financial instrument.

FinancialDerivative[instrument,params,ambientparams,prop] computes the specified property prop.

FinancialIndicator

FinancialIndicator["ind",par1,par2,…] represents a financial indicator "ind" with parameters par1, par2, etc. 

Find

Find[stream,"text"] finds the first line in an input stream that contains the specified string. 

Find[stream,{"text1","text2",…}] finds the first line that contains any of the specified strings. 

FindAnomalies

FindAnomalies[{example1,example2,…}] gives a list of the examplei that are considered anomalous with respect to the other examples.

FindAnomalies[examples,prop] gives the specified property related to the anomaly computation.

FindAnomalies[examples,{prop1,prop2,…}] gives the properties propi.

FindAnomalies[fun,data] finds anomalies in data using the given AnomalyDetectorFunction[…] or LearnedDistribution[…].

FindAnomalies[fun,data,props] gives properties related to the anomaly computation.

FindArgMax

FindArgMax[f,x] gives the position xmax of a local maximum of f.

FindArgMax[f,{x,x0}] gives the position xmax of a local maximum of f, found by a search starting from the point x=x0. 

FindArgMax[f,{{x,x0},{y,y0},…}] gives the position {xmax,ymax,…} of a local maximum of a function of several variables. 

FindArgMax[{f,cons},{{x,x0},{y,y0},…}] gives the position of a local maximum subject to the constraints cons.

FindArgMax[{f,cons},{x,y,…}] starts from a point within the region defined by the constraints.

FindArgMin

FindArgMin[f,x] gives the position xmin of a local minimum of f.

FindArgMin[f,{x,x0}] gives the position xmin of a local minimum of f, found by a search starting from the point x=x0. 

FindArgMin[f,{{x,x0},{y,y0},…}] gives the position {xmin,ymin,…} of a local minimum of a function of several variables. 

FindArgMin[{f,cons},{{x,x0},{y,y0},…}] gives the position of a local minimum subject to the constraints cons.

FindArgMin[{f,cons},{x,y,…}] starts from a point within the region defined by the constraints.

FindChannels

FindChannels[] gives a list of channels in your home area on the channel broker server.

FindChannels[None] gives a list of your unnamed channels.

FindChannels[All] gives a list of all channels owned by you.

FindChannels[form] gives a list of channels in your home area whose names match the string pattern form.

FindChannels["/�] gives a list of channels whose names match the string pattern "/abspath".

FindChannels["mqtts://…"] gives a list of channels whose names match the specified pattern representing a URL.

FindClique

FindClique[g] finds a largest clique in the graph g.

FindClique[g,n] finds a clique containing at most n vertices.

FindClique[g,{n}] finds a clique containing exactly n vertices.

FindClique[g,{nmin,nmax}] finds a clique containing between nmin and nmax vertices.

FindClique[g,nspec,s] finds at most s cliques.

FindClique[{g,v},…] finds cliques that include the vertex v only.

FindClique[{v->w,…},…] uses rules v->w to specify the graph g.

FindClusters

FindClusters[{e1,e2,…}] partitions the ei into clusters of similar elements. 

FindClusters[{e1->v1,e2->v2,…}] returns the vi corresponding to the ei in each cluster.

FindClusters[data,n] partitions data into n clusters. 

FindCookies

FindCookies[] gives a list of all currently set cookies.

FindCookies[domain] gives a list of cookies associated with the specified domain.

FindCookies[assoc] gives a list of cookies whose attributes match the specification in the association assoc.

FindCurvePath

FindCurvePath[{{x1,y1},{x2,y2},…}] gives an ordering of the {xi,yi} that corresponds to one or more smooth curves.

FindCycle

FindCycle[g] finds a cycle in the graph g.

FindCycle[g,k] finds a cycle of length at most k in the graph g.

FindCycle[g,{k}] finds a cycle of length exactly k.

FindCycle[g,{kmin,kmax}] finds a cycle of length between kmin and kmax.

FindCycle[g,kspec,s] finds at most s cycles.

FindCycle[{g,v},…] finds cycles that include the vertex v.

FindCycle[{v->w,…},…] uses rules v->w to specify the graph g.

FindDevices

FindDevices[] searches for available devices on your computer system.

FindDevices[form] gives a list of devices in classes whose names match the string pattern form.

FindDevices[{form1,form2,…}] gives a list of devices in classes whose names match any of the formi.

FindDevices[forms,n] returns at most n devices.

FindDistribution

FindDistribution[data] finds a simple functional form to fit the distribution of data.

FindDistribution[data,n] finds up to n best distributions.

FindDistribution[data,n,prop] returns up to n best distributions associated with property prop.

FindDistribution[data,n,{prop1,prop2,…}] returns up to n best distributions associated with properties prop1, prop2, etc.

FindDistributionParameters

FindDistributionParameters[data,dist] finds the parameter estimates for the distribution dist from data.

FindDistributionParameters[data,dist,{{p,p0},{q,q0},…}] finds the parameters p, q, … with starting values p0, q0, ….

FindDivisions

FindDivisions[{xmin,xmax},n] finds a list of about n "nice" numbers that divide the interval around xmin to xmax into equally spaced parts. 

FindDivisions[{xmin,xmax,dx},n] makes the parts always have lengths that are integer multiples of dx. 

FindDivisions[{xmin,xmax},{n1,n2,…}] finds successive subdivisions into about n1, n2, … parts. 

FindDivisions[{xmin,xmax,{dx1,dx2,…}},{n1,n2,…}] uses spacings that are forced to be multiples of dx1, dx2, …. 

FindEdgeColoring

FindEdgeColoring[g] finds a coloring with minimal size for the edges in the graph g.

FindEdgeColoring[g,{c1,c2,…}] finds a coloring {c1,c2,…,ck} for the edges in the graph g.

FindEdgeCover

FindEdgeCover[g] finds an edge cover of the graph g with a minimum number of edges.

FindEdgeCover[{v->w,…}] uses rules v->w to specify the graph g.

FindEdgeCut

FindEdgeCut[g] finds a smallest edge cut of the graph g.

FindEdgeCut[g,s,t] finds a smallest s-t edge cut of the graph g.

FindEdgeCut[{v->w,…},…] uses rules v->w to specify the graph g.

FindEdgeIndependentPaths

FindEdgeIndependentPaths[g,s,t,k] finds at most k edge-independent paths from vertex s to vertex t in the graph g.

FindEdgeIndependentPaths[{v->w,…},…] uses rules v->w to specify the graph g.

FindEquationalProof

FindEquationalProof[thm,axms] tries to find an equational proof of the symbolic theorem thm using the axioms axms.

FindEquationalProof[thm,"theory"] tries to find a proof of thm using the specified named axiomatic theory.

FindEulerianCycle

FindEulerianCycle[g] finds an Eulerian cycle in the graph g.

FindEulerianCycle[g,k] finds at most k Eulerian cycles.

FindEulerianCycle[{v->w,…},…] uses rules v->w to specify the graph g.

FindExternalEvaluators

FindExternalEvaluators[] finds installed external evaluators that can be used with ExternalEvaluate, returning a dataset of the results found.

FindExternalEvaluators["sys"] finds only external evaluators for language or system sys.

FindFile

FindFile[name] finds the file with the specified name that would be loaded by Get[name] and related functions.

FindFit

FindFit[data,expr,pars,vars] finds numerical values of the parameters pars that make expr give a best fit to data as a function of vars. 

FindFit[data,{expr,cons},pars,vars] finds a best fit subject to the parameter constraints cons.

FindFit[data,exprspec,pars,vars,"prop"]  specifies what fit property prop should be returned.

FindFormula

FindFormula[data] finds a pure function that approximates data.

FindFormula[data,x] finds a symbolic function of the variable x that approximates data.

FindFormula[data,x,n] finds up to n functions that approximate data.

FindFormula[data,x,n,prop] returns up to n best functions associated with property prop.

FindFormula[data,x,n,{prop1,prop2,…}] returns up to n best functions associated with properties prop1, prop2, etc.

FindFundamentalCycles

FindFundamentalCycles[g] finds fundamental cycles of the graph g.

FindGeneratingFunction

FindGeneratingFunction[{a0,a1,…},x] attempts to find a simple generating function in x whose nth series coefficient is an.

FindGeneratingFunction[{{n0,a0},{n1,a1},…},x] attempts to find a simple generating function whose nith series coefficient is ai. 

FindGeoLocation

FindGeoLocation[] attempts to find the current geo location of your computer.

FindGeoLocation["ip"] gives an estimate of the geo location associated with the IP address given.

FindGeoLocation["address"] attempts to find the geo location associated with the street address given.

FindGeoLocation[entity] gives the geo location associated with the specified entity.

FindGeometricConjectures

FindGeometricConjectures[scene] finds conjectures that appear to hold for the GeometricScene object scene and adds these conjectures to the scene object.

FindGeometricConjectures[{scene1,scene2,…}] finds conjectures that appear to hold for all instances scenei of a geometric scene and returns a combined scene with the conjectures added.

FindGeometricConjectures[scenes,patt] adds only conjectures that match the pattern patt.

FindGeometricConjectures[scenes,patt,n] adds only up to n conjectures.

FindGeometricTransform

FindGeometricTransform[pts1,pts2] finds a geometric transformation that aligns positions specified by pts2 with pts1, returning the alignment error together with the transformation function.

FindGeometricTransform[ref,{pts1,pts2,…}] finds geometric transformations that align each of the ptsi with ref. 

FindGeometricTransform[{pts1,pts2,…}] finds geometric transformations that align each of the ptsi with pts1.

FindGraphCommunities

FindGraphCommunities[g] finds communities in the graph g.

FindGraphCommunities[{v->w,…}] uses rules v->w to specify the graph g.

FindGraphIsomorphism

FindGraphIsomorphism[g1,g2] finds an isomorphism that maps the graph g1 to g2 by renaming vertices.

FindGraphIsomorphism[g1,g2,n] finds at most n isomorphisms. 

FindGraphIsomorphism[{v->w,…},…] uses rules v->w to specify the graph g.

FindGraphPartition

FindGraphPartition[g] gives a partition of vertices of the graph g.

FindGraphPartition[g,k] gives a partition of vertices into k approximately equal-size parts.

FindGraphPartition[g,{n1,…,nk}] gives a partition of vertices into parts with sizes n1, …, nk.

FindGraphPartition[g,{α1,…,αk}] gives a partition of vertices into parts with approximate size proportions α1, …, αk.

FindGraphPartition[{v->w,…},…] uses rules v->w to specify the graph g.

FindHamiltonianCycle

FindHamiltonianCycle[g] finds a Hamiltonian cycle in the graph g.

FindHamiltonianCycle[g,k] finds at most k Hamiltonian cycles.

FindHamiltonianCycle[{v->w,…},…] uses rules v->w to specify the graph g.

FindHamiltonianPath

FindHamiltonianPath[g] finds a Hamiltonian path in the graph g with the smallest total length.

FindHamiltonianPath[g,s,t] finds a Hamiltonian path with the smallest total length from s to t.

FindHiddenMarkovStates

FindHiddenMarkovStates[data,hmm] finds the most likely hidden states of the HiddenMarkovProcess hmm corresponding to the emissions data.

FindHiddenMarkovStates[data,hmm,crit] uses the given criterion crit to find the hidden states.

FindIndependentEdgeSet

FindIndependentEdgeSet[g] finds an independent edge set of the graph g with a maximum number of edges.

FindIndependentEdgeSet[{v->w,…}] uses rules v->w to specify the graph g.

FindIndependentVertexSet

FindIndependentVertexSet[g] finds an independent vertex set of the graph g with a maximum number of vertices.

FindIndependentVertexSet[g,n] finds an independent vertex set with at most n vertices.

FindIndependentVertexSet[g,{n}] finds an independent vertex set with exactly n vertices.

FindIndependentVertexSet[g,{nmin,nmax}] finds an independent vertex set containing between nmin and nmax vertices.

FindIndependentVertexSet[g,nspec,s] finds at most s independent vertex sets.

FindIndependentVertexSet[{g,v},…] finds independent sets that include the vertex v only.

FindIndependentVertexSet[{v->w,…},…] uses rules v->w to specify the graph g.

FindInstance

FindInstance[expr,vars] finds an instance of vars that makes the statement expr be True. 

FindInstance[expr,vars,dom] finds an instance over the domain dom. Common choices of dom are Complexes, Reals, Integers, and Booleans. 

FindInstance[expr,vars,dom,n] finds n instances. 

FindIntegerNullVector

FindIntegerNullVector[{x1,x2,…,xn}] finds a list of integers ai such that a1 x1+a2 x2+⋯+an xn0. 

FindIntegerNullVector[{x1,x2,…,xn},d] finds a list of integers ai with {a1,…,an}≤d such that a1 x1+a2 x2+⋯+an xn0. 

FindIsomorphicSubgraph

FindIsomorphicSubgraph[g1,g2] finds a subgraph of g1 that is isomorphic to g2.

FindIsomorphicSubgraph[g1,g2,n] finds at most n subgraphs.

FindKClan

FindKClan[g,k] finds a largest k-clan in the graph g.

FindKClan[g,k,n] finds a k-clan containing at most n vertices.

FindKClan[g,k,{n}] finds a k-clan containing exactly n vertices.

FindKClan[g,k,{nmin,nmax}] finds a k-clan containing between nmin and nmax vertices.

FindKClan[g,k,nspec,s] finds at most s k-clans.

FindKClan[{g,v},k,…] finds k-clans that include the vertex v only.

FindKClan[{v->w,…},…] uses rules v->w to specify the graph g.

FindKClique

FindKClique[g,k] finds a largest k-clique in the graph g.

FindKClique[g,k,n] finds a k-clique containing at most n vertices.

FindKClique[g,k,{n}] finds a k-clique containing exactly n vertices.

FindKClique[g,k,{nmin,nmax}] finds a k-clique containing between nmin and nmax vertices.

FindKClique[g,k,nspec,s] finds at most s k-cliques.

FindKClique[{g,v},k,…] finds k-cliques that include the vertex v only.

FindKClique[{v->w,…},…] uses rules v->w to specify the graph g.

FindKClub

FindKClub[g,k] finds a largest k-club in the graph g.

FindKPlex

FindKPlex[g,k] finds a largest k-plex in the graph g.

FindKPlex[g,k,n] finds a k-plex containing at most n vertices.

FindKPlex[g,k,{n}] finds a k-plex containing exactly n vertices.

FindKPlex[g,k,{nmin,nmax}] finds a k-plex containing between nmin and nmax vertices.

FindKPlex[g,k,nspec,s] finds at most s k-plexes.

FindKPlex[{g,v},k,…] finds k-plexes that include the vertex v only.

FindKPlex[{v->w,…},…] uses rules v->w to specify the graph g.

FindLibrary

FindLibrary[lib] finds a dynamic library that can be loaded by LibraryFunctionLoad.

FindLinearRecurrence

FindLinearRecurrence[list] finds if possible the minimal linear recurrence that generates list.

FindLinearRecurrence[list,d] finds if possible the linear recurrence of maximum order d that generates list.

FindList

FindList["file","text"] gives a list of lines in the file that contain the specified string. 

FindList["file",{"text1","text2",…}] gives a list of all lines that contain any of the specified strings. 

FindList[{"file1",…},…] gives a list of lines containing the specified strings in any of the filei. 

FindList[files,text,n] includes only the first n lines found. 

FindMatchingColor

FindMatchingColor[image,color] returns a color similar to the color that is present in image.

FindMatchingColor[image,{color1,color2,…}] returns a list of colors matching each colori.

FindMatchingColor[{image1,image2,…},{color1,color2,…}] returns lists of matching colors for all imagei.

FindMaximum

FindMaximum[f,x] searches for a local maximum in f, starting from an automatically selected point.

FindMaximum[f,{x,x0}] searches for a local maximum in f, starting from the point x=x0. 

FindMaximum[f,{{x,x0},{y,y0},…}] searches for a local maximum in a function of several variables. 

FindMaximum[{f,cons},{{x,x0},{y,y0},…}] searches for a local maximum subject to the constraints cons.

FindMaximum[{f,cons},{x,y,…}] starts from a point within the region defined by the constraints.

FindMaximumCut

FindMaximumCut[g] gives the maximum cut of the graph g.

FindMaximumFlow

FindMaximumFlow[g,s,t] finds the maximum flow between source vertex s and target vertex t in a graph g.

FindMaximumFlow[m,s,t] finds the maximum flow between vertex indices s and t in a graph with edge capacity matrix m.

FindMaximumFlow[data,{s1,…},{t1,…}] finds the maximum flow between multi-sources s1, … and multi-targets t1, ….

FindMaximumFlow[data,source,target,"property"] returns the value of "property".

FindMaximumFlow[{v->w,…},…] uses rules v->w to specify the graph g.

FindMaxValue

FindMaxValue[f,x] gives the value at a local maximum of f.

FindMaxValue[f,{x,x0}] gives the value at a local maximum of f, found by a search starting from the point x=x0. 

FindMaxValue[f,{{x,x0},{y,y0},…}] gives the value at a local maximum of a function of several variables. 

FindMaxValue[{f,cons},{{x,x0},{y,y0},…}] gives the value at a local maximum subject to the constraints cons.

FindMaxValue[{f,cons},{x,y,…}] starts from a point within the region defined by the constraints.

FindMeshDefects

FindMeshDefects[mreg] finds defects in the mesh region mreg.

FindMeshDefects[mreg,{def1,…}] finds only the specified type of defects def1, ….

FindMeshDefects[mreg,defects,format] formats the results according to format specification.

FindMinimum

FindMinimum[f,x] searches for a local minimum in f, starting from an automatically selected point.

FindMinimum[f,{x,x0}] searches for a local minimum in f, starting from the point x=x0. 

FindMinimum[f,{{x,x0},{y,y0},…}] searches for a local minimum in a function of several variables. 

FindMinimum[{f,cons},{{x,x0},{y,y0},…}] searches for a local minimum subject to the constraints cons.

FindMinimum[{f,cons},{x,y,…}] starts from a point within the region defined by the constraints.

FindMinimumCostFlow

FindMinimumCostFlow[g,{sd1,sd2,…}] finds the minimum cost flow in the graph g with sd1, sd2, … vertex supplies or demands.

FindMinimumCostFlow[g,s,t] finds the minimum cost maximum flow between source vertex s and target vertex t in a graph g.

FindMinimumCostFlow[g,s,t,d] finds the minimum cost flow between source s and target t, with the required flow d.

FindMinimumCostFlow[m,…] finds the minimum cost flow in a graph with cost matrix m.

FindMinimumCostFlow[data,…,"property"] returns the value of "property".

FindMinimumCostFlow[{v->w,…},…] uses rules v->w to specify the graph g.

FindMinimumCut

FindMinimumCut[g] gives the minimum cut of the graph g.

FindMinimumCut[{v->w,…}] uses rules v->w to specify the graph g.

FindMinValue

FindMinValue[f,x] gives the value at a local minimum of f.

FindMinValue[f,{x,x0}] gives the value at a local minimum of f, found by a search starting from the point x=x0. 

FindMinValue[f,{{x,x0},{y,y0},…}] gives the value at a local minimum of a function of several variables. 

FindMinValue[{f,cons},{{x,x0},{y,y0},…}] gives the value at a local minimum subject to the constraints cons.

FindMinValue[{f,cons},{x,y,…}] starts from a point within the region defined by the constraints.

FindMoleculeSubstructure

FindMoleculeSubstructure[mol,patt] finds a mapping between the atom indices in mol and an occurrence of patt in mol.

FindMoleculeSubstructure[mol,patt,All] finds all occurrences of patt in mol and returns all mappings.

FindMoleculeSubstructure[mol,patt,n] finds at most n mappings.

FindPath

FindPath[g,s,t] finds a path between vertex s and vertex t in the graph g.

FindPath[g,s,t,k] finds a path of length at most k between vertex s and vertex t in the graph g.

FindPath[g,s,t,{k}] finds a path of length exactly k.

FindPath[g,s,t,{kmin,kmax}] finds a path of length between kmin and kmax.

FindPath[g,s,t,kspec,n] finds at most n paths.

FindPath[{v->w,…},…] uses rules v->w to specify the graph g.

FindPeaks

FindPeaks[list] gives positions and values of the detected peaks in list.

FindPeaks[list,σ] finds peaks that survive Gaussian blurring up to scale σ.

FindPeaks[list,σ,s] finds peaks with minimum sharpness s.

FindPeaks[list,σ,s,t] finds only peaks with values greater than t.

FindPeaks[list,σ,{s,σs},{t,σt}] uses different scales for thresholding sharpness and value.

FindPermutation

FindPermutation[expr] gives a permutation that produces expr by permuting Sort[expr].

FindPermutation[expr1,expr2] gives a permutation that converts expr1 to expr2 for two expressions that differ only in the order of their arguments.

FindPlanarColoring

FindPlanarColoring[g] finds a coloring with minimal size for the faces of the planar graph g.

FindPlanarColoring[g,{c1,c2,…}] finds a coloring {c1,c2,…,ck} for the faces in the graph g.

FindPointProcessParameters

FindPointProcessParameters[pdata,pproc] estimates the parameters of the point process pproc from point data pdata.

FindPointProcessParameters[pdata,pproc,{{p,p0},{q,q0},…}] estimates the parameters p, q, … with starting values p0, q0, ….

FindPostmanTour

FindPostmanTour[g] finds a Chinese postman tour in the graph g of minimal length.

FindPostmanTour[g,k] finds at most k Chinese postman tours. 

FindPostmanTour[{v->w,…},…] uses rules v->w to specify the graph g.

FindProcessParameters

FindProcessParameters[data,proc] finds the parameter estimates for the process proc from data.

FindProcessParameters[data,proc,{{p,p0},{q,q0},…}] finds the parameters p, q, … with starting values p0, q0, … .

FindRegionTransform

FindRegionTransform[reg1,reg2] gives the transformation function that maps the region reg1 to the region reg2.

FindRepeat

FindRepeat[list] finds the minimal sublist or subarray that repeats to give list.

FindRepeat[list,n] requires that the sublist be repeated at least n times in list.

FindRepeat[list,{n1,n2,…}] requires ni to repeat at level i in list.

FindRepeat["string"] finds the minimal substring that repeats to give string.

FindRepeat["string",n] requires that the substring be repeated at least n times.

FindRoot

FindRoot[f,{x,x0}] searches for a numerical root of f, starting from the point x=x0.

FindRoot[lhs==rhs,{x,x0}] searches for a numerical solution to the equation lhs==rhs. 

FindRoot[{f1,f2,…},{{x,x0},{y,y0},…}] searches for a simultaneous numerical root of all the fi.

FindRoot[{eqn1,eqn2,…},{{x,x0},{y,y0},…}] searches for a numerical solution to the simultaneous equations eqni. 

FindSequenceFunction

FindSequenceFunction[{a1,a2,a3,…}] attempts to find a simple function that yields the sequence an when given successive integer arguments.

FindSequenceFunction[{{n1,a1},{n2,a2},…}] attempts to find a simple function that yields ai when given argument ni.

FindSequenceFunction[<|n1->a1,n2->a2,…|>] gives a function that yields ai when given argument ni.

FindSequenceFunction[{n1->a1,n2->a2,…}] gives a function that yields ai when given argument ni.

FindSequenceFunction[list,n] gives the function applied to n.

FindShortestPath

FindShortestPath[g,s,t] finds the shortest path from source vertex s to target vertex t in the graph g.

FindShortestPath[g,s,All] generates a ShortestPathFunction[…] that can be applied repeatedly to different t.

FindShortestPath[g,All,t] generates a ShortestPathFunction[…] that can be applied repeatedly to different s.

FindShortestPath[g,All,All] generates a ShortestPathFunction[…] that can be applied to different s and t.

FindShortestPath[{v->w,…},…] uses rules v->w to specify the graph g. 

FindShortestTour

FindShortestTour[{v1,v2,…}] attempts to find an ordering of the vi that minimizes the total distance on a tour that visits all the vi once.

FindShortestTour[graph] attempts to find an ordering of the vertices in graph that minimizes the total length when visiting each vertex once.

FindShortestTour[{v1,v2,…},j,k] finds an ordering of the vi that minimizes the total distance on a path from vj to vk.

FindShortestTour[graph,s,t] finds an ordering of the vertices that minimizes the total length on a path from s to t.

FindShortestTour[{v->w,…},…] uses rules v->w to specify the graph g. 

FindShortestTour[data->prop,…] gives the property prop for data.

FindSpanningTree

FindSpanningTree[{v1,v2,…,vn}] finds a spanning tree that minimizes the total distance between the vi.

FindSpanningTree[g] finds a spanning tree of the graph g that minimizes the total distances between vertices.

FindSpanningTree[{g,v},…] finds a spanning tree of the connected component of g that includes the vertex v. 

FindSpanningTree[{v->w,…},…] uses rules v->w to specify the graph g. 

FindSubgraphIsomorphism

FindSubgraphIsomorphism[g1,g2] finds a subgraph isomorphism that maps the graph g1 to a subgraph of g2 by renaming vertices.

FindSubgraphIsomorphism[g1,g2,n] finds at most n subgraph isomorphisms.

FindTextualAnswer

FindTextualAnswer[text,"question"] gives the substring of text that best appears to answer question.

FindTextualAnswer[text,"question",n] gives a list of up to n answers that appear most probable.

FindTextualAnswer[text,"question",n,prop] gives the specified property for each answer.

FindThreshold

FindThreshold[image] finds a global threshold value that partitions the intensity values in image into two intervals.

FindTransientRepeat

FindTransientRepeat[list,n] returns a pair of lists {transient,repeat} where the elements of repeat occur successively at least n times after the elements of the transient part of list.

FindTransientRepeat[string,n] returns a pair of strings {transient,repeat}.

FindVertexColoring

FindVertexColoring[g] finds a coloring with minimal size for the vertices in the graph g. 

FindVertexColoring[g,{c1,c2,…}] finds a coloring {c1,c2,…,ck} for the vertices in the graph g.

FindVertexCover

FindVertexCover[g] finds a vertex cover of the graph g with a minimum number of vertices.

FindVertexCover[{v->w,…}] uses rules v->w to specify the graph g. 

FindVertexCut

FindVertexCut[g] finds a smallest vertex cut of the graph g.

FindVertexCut[g,s,t] finds a smallest s-t vertex cut of the graph g.

FindVertexCut[{v->w,…},…] uses rules v->w to specify the graph g. 

FindVertexIndependentPaths

FindVertexIndependentPaths[g,s,t,k] finds at most k vertex-independent paths from vertex s to vertex t in the graph g.

FindVertexIndependentPaths[{v->w,…},…] uses rules v->w to specify the graph g. 

FiniteAbelianGroupCount

FiniteAbelianGroupCount[n] gives the number of finite Abelian groups of order n.

FiniteGroupCount

FiniteGroupCount[n] gives the number of finite groups of order n.

FiniteGroupData

FiniteGroupData[name,"property"] gives the value of the specified property for the finite group specified by name.

FiniteGroupData["class"] gives a list of finite groups in the specified class.

First

First[expr] gives the first element in expr. 

First[expr,def] gives the first element if it exists, or def otherwise.

FirstCase

FirstCase[{e1,e2,…},pattern] gives the first ei to match pattern, or Missing["NotFound"] if none matching pattern is found. 

FirstCase[{e1,…},pattern->rhs] gives the value of rhs corresponding to the first ei to match pattern.

FirstCase[expr,pattern,default] gives default if no element matching pattern is found. 

FirstCase[expr,pattern,default,levelspec] finds only objects that appear on levels specified by levelspec. 

FirstCase[pattern] represents an operator form of FirstCase that can be applied to an expression.

FirstPassageTimeDistribution

FirstPassageTimeDistribution[mproc,f] represents the distribution of times for the Markov process mproc to pass from the initial state to final states f for the first time. 

FirstPosition

FirstPosition[expr,pattern] gives the position of the first element in expr that matches pattern, or Missing["NotFound"] if no such element is found.

FirstPosition[expr,pattern,default] gives default if no element matching pattern is found.

FirstPosition[expr,pattern,default,levelspec] finds only objects that appear on levels specified by levelspec. 

FirstPosition[pattern] represents an operator form of FirstPosition that can be applied to an expression.

FischerGroupFi22

FischerGroupFi22[] represents the sporadic simple Fischer group Fi22.

FischerGroupFi23

FischerGroupFi23[] represents the sporadic simple Fischer group Fi23.

FischerGroupFi24Prime

FischerGroupFi24Prime[] represents the sporadic simple Fischer group Fi24′.

FisherHypergeometricDistribution

FisherHypergeometricDistribution[n,nsucc,ntot,w] represents a Fisher noncentral hypergeometric distribution.

FisherZDistribution

FisherZDistribution[n,m] represents a Fisher z distribution with n numerator and m denominator degrees of freedom.

Fit

Fit[data,{f1,…,fn},{x,y,…}] finds a fit a1⁢f1+…+an⁢fn to a list of data for functions f1,…,fn of variables {x,y,…}. 

Fit[{m,v}] finds a fit vector a that minimizes ||m.a-v|| for a design matrix m.

Fit[…,"prop"] specifies what fit property prop should be returned.

FitRegularization

FitRegularization is an option for Fit and FindFit that specifies a regularization for fitting a model.

FittedModel

FittedModel[…] represents the symbolic fitted model obtained from functions like LinearModelFit.

FixedOrder

FixedOrder[p1,p2,…] is a grammar rules pattern object that represents a sequence of elements matching p1, p2, …, in the fixed order given.

FixedPoint

FixedPoint[f,expr] starts with expr, then applies f repeatedly until the result no longer changes.

FixedPoint[f,expr,n] stops after at most n steps.

FixedPointList

FixedPointList[f,expr] generates a list giving the results of applying f repeatedly, starting with expr, until the results no longer change.

FixedPointList[f,expr,n] stops after at most n steps.

Flat

Flat is an attribute that can be assigned to a symbol f to indicate that all expressions involving nested functions f should be flattened out. This property is accounted for in pattern matching. 

Flatten

Flatten[list] flattens out nested lists. 

Flatten[list,n] flattens to level n. 

Flatten[list,n,h] flattens subexpressions with head h. 

Flatten[list,{{s11,s12,…},{s21,s22,…},…}] flattens list by combining all levels sij to make each level i in the result. 

FlattenAt

FlattenAt[list,n] flattens out a sublist that appears as the nth element of list. If n is negative, the position is counted from the end. 

FlattenAt[expr,{i,j,…}] flattens out the part of expr at position {i,j,…}. 

FlattenAt[expr,{{i1,j1,…},{i2,j2,…},…}] flattens out parts of expr at several positions.

FlattenAt[pos] represents an operator form of FlattenAt that can be applied to an expression.

FlattenLayer

FlattenLayer[] represents a net layer that flattens any input array into a vector.

FlattenLayer[n] represents a net layer that flattens its input to level n.

FlattenLayer[{{s11,s12,…},{s21,s22,…},…}] represents a net layer that flattens its input by combining all levels sij to make each level i in the result.

FlatTopWindow

FlatTopWindow[x] represents an exact flat top window function of x.

FlightData

FlightData[spec,options] returns a subset of properties for a flight or selection of flights with specifications spec.

FlightData[spec,prop,options] returns the value of the property prop for specifications spec.

FlightData[spec,prop,datespec,options] returns the value of the property prop for a specific time or time range datespec.

FlipView

FlipView[{expr1,expr2}] represents an object which flips between displaying expr1 and expr2 each time it is clicked.

FlipView[{expr1,expr2,…}] cyclically flips through successive expri.

FlipView[{expr1,expr2,…},i] makes expri be the object currently displayed.

Floor

Floor[x] gives the greatest integer less than or equal to x. 

Floor[x,a] gives the greatest multiple of a less than or equal to x. 

FlowPolynomial

FlowPolynomial[g,k] gives the flow polynomial of the graph g.

FlowPolynomial[{v->w,…},…] uses rules v->w to specify the graph g. 

Fold

Fold[f,x,list] gives the last element of FoldList[f,x,list].

Fold[f,list] is equivalent to Fold[f,First[list],Rest[list]].

Fold[f] represents an operator form of Fold that can be applied to expressions. 

FoldList

FoldList[f,x,{a,b,…}] gives {x,f[x,a],f[f[x,a],b],…}. 

FoldList[f,{a,b,c,…}] gives {a,f[a,b],f[f[a,b],c],…}.

FoldList[f] represents an operator form of FoldList that can be applied to expressions. 

FoldPair

FoldPair[f,y0,list] gives the last element of FoldPairList[f,y0,list].

FoldPair[f,y0,list,g] gives the last element of FoldPairList[f,y0,list,g].

FoldPair[f,{a0,a1,a2,…}] is equivalent to FoldPair[f,a0,{a1,a2,…}].

FoldPairList

FoldPairList[f,y0,{a1,a2,…}] gives the list of successive xi obtained by applying f to pairs of the form {yi-1,ai}, where at each step f returns {xi,yi}.

FoldPairList[f,y0,list,g] gives the list of successive values of g[{xi,yi}].

FoldPairList[f,{a0,a1,a2,…}] is equivalent to FoldPairList[f,a0,{a1,a2,…}].

FoldWhile

FoldWhile[f,x,{a1,a2,…},test] returns the first expression f[… f[f[x,a1],a2]…,ak] to which applying test does not yield True.

FoldWhile[f,list,test] is equivalent to FoldWhile[f,First[list],Rest[list],test].

FoldWhile[f,x,{a1,a2,…},test,m] supplies the most recent m results as arguments for test at each step.

FoldWhile[f,x,{a1,a2,…},test,All] supplies all results so far as arguments for test at each step. 

FoldWhile[f,x,{a1,a2,…},test,m,n] returns the result after applying f an extra n times after test fails.

FoldWhile[f,x,{a1,a2,…},test,m,-n] returns the result found when f had been applied n fewer times.

FoldWhile[f,test] represents an operator form of FoldWhile that can be applied to expressions.

FoldWhileList

FoldWhileList[f,x,{a1,a2,…},test] returns {x,f[x,a1],f[f[x,a1],a2],…}, repeatedly applying f with subsequent values ai until applying test to the result does not yield True.

FoldWhileList[f,list,test] is equivalent to FoldWhileList[f,First[list],Rest[list],test].

FoldWhileList[f,x,{a1,a2,…},test,m] supplies the most recent m results as arguments for test at each step.

FoldWhileList[f,x,{a1,a2,…},test,All] supplies all results so far as arguments for test at each step.

FoldWhileList[f,x,{a1,a2,…},test,m,n] returns n additional results by applying f an extra n times after test fails.

FoldWhileList[f,x,{a1,a2,…},test,m,-n] returns n fewer results.

FoldWhileList[f,test] represents an operator form of FoldWhileList that can be applied to expressions.

FollowRedirects

FollowRedirects is an option for URLRead and related functions that specifies whether to follow HTTP redirects when retrieving a URL.

FontColor

FontColor is an option for Style, Cell, and related constructs that specifies the default color in which to render text. 

FontFamily

FontFamily is an option for Style and Cell that specifies the font family in which text should be rendered. 

FontSize

FontSize is an option for Style and Cell that specifies the default size in printer's points of the font in which to render text. 

FontSlant

FontSlant is an option for Style, Cell, and related constructs that specifies how slanted characters in text should be. 

FontSubstitutions

FontSubstitutions is a global option that gives a list of substitutions to try for font family names. 

FontTracking

FontTracking is an option for Style and Cell that specifies how condensed or expanded you want the font in which text is rendered to be. 

FontVariations

FontVariations is an option for Style, Cell, and related constructs that specifies what font variations should be used.

FontWeight

FontWeight is an option for Style, Cell, and related constructs that specifies how heavy the characters in a font should be. 

For

For[start,test,incr,body] executes start, then repeatedly evaluates body and incr until test fails to give True. 

ForAll

ForAll[x,expr] represents the statement that expr is True for all values of x. 

ForAll[x,cond,expr] states that expr is True for all x satisfying the condition cond. 

ForAll[{x1,x2,…},expr] states that expr is True for all values of all the xi. 

ForceVersionInstall

ForceVersionInstall is an option to PacletInstall and PacletInstallSubmit that specifies whether an older version of a paclet is allowed to be installed if a newer version is already installed.

Format

Format[expr] prints as the formatted form of expr. Assigning values to Format[expr] defines print forms for expressions. 

Format[expr,form] gives a format for the specified form of output. 

FormatType

FormatType is an option for output streams, graphics, and functions such as Text that specifies the default format type to use when outputting expressions. 

FormatValues

FormatValues[f] gives a list of transformation rules corresponding to all printing formats (values for Format[f[x,…],…], etc.) defined for the symbol f.

FormFunction

FormFunction[formspec,func] represents an active form that, when submitted, applies func to the values obtained from the form specified by formspec.

FormFunction[{name1->type1,…},func] represents an active form with fields named namei interpreted as types typei.

FormFunction[{{name1,label1}->type1,…},func] uses labeli as the label for the field named namei.

FormFunction[{namespec1->type1->default1,…},func] uses defaulti as the default for the field specified by namespeci.

FormFunction[formspec,func,fmt] specifies that in the cloud, the result from applying func should be returned in format fmt.

FormFunction[{formspec1,formspec2,…},func,…] represents a multipage form, in which the successive formspeci can be functions that are applied to the values obtained so far.

FormLayoutFunction

FormLayoutFunction is an option for FormObject and FormFunction that can be used to specify how to lay out a form.

FormObject

FormObject[{name1->type1,name2->type2,…}] represents a form with fields having names namei that take data of type typei.

FormObject[{{name1,label1}->type1,…}] uses labeli as the label for the field named namei.

FormObject[{name1->assoc1,…,objj,…}] uses full specification associ for a field, and objj as part of the layout of the form.

FormPage

FormPage[formspec,func] represents an active page that takes input from a form and generates results on the same page by applying func to the values obtained from the form whose structure is defined by formspec.

FormPage[{name1->type1,…},func] represents an active form page with fields named namei interpreted as types typei.

FormPage[{{name1,label1}->type1,…},func] uses labeli as the label for the field named namei.

FormPage[{namespec1->type1->default1,…},func] uses defaulti as the default for the field specified by namespeci.

FormPage[formspec,func,form] lays out the page according to the layout specification form.

FormPage[formspec,func,initform->resform] uses initform as the initial layout specification and resform as the layout specification for result pages.

FormProtectionMethod

FormProtectionMethod is an option for form generation functions that specifies what method to use for protecting the form against spam and other undesired submissions.

FormTheme

FormTheme is an option for FormObject and related functions that specifies an overall theme for a form and its elements.

FormulaData

FormulaData[name] gives the equations for the formula name.

FormulaData[name,{var1->quantity1,var2->quantity2,…}] solves or simplifies equations using the specified values quantityi for the variables vari.

FormulaData[name,"property"] gives the value of the specified property for the formula name.

FormulaLookup

FormulaLookup["query"] gives a list of the full names of formulas whose names are consistent with "query".

FormulaLookup["query",n] returns at most n results.

FormulaLookup["class"] returns the names of all formulas within that class.

FortranForm

FortranForm[expr] prints as a Fortran language version of expr. 

Forward

Forward is a symbol that represents the forward direction for purposes of motion and animation.

ForwardBackward

ForwardBackward is a symbol that represents alternate forward and backward motion or animation.

ForwardCloudCredentials

ForwardCloudCredentials is an option for remote evaluation and submission functions that specifies whether Wolfram Cloud credentials from the local session should be copied into remote sessions.

Fourier

Fourier[list] finds the discrete Fourier transform of a list of complex numbers.

Fourier[list,{p1,p2,…}] returns the specified positions of the discrete Fourier transform. 

FourierCoefficient

FourierCoefficient[expr,t,n] gives the nth coefficient in the Fourier series expansion of expr.

FourierCoefficient[expr,{t1,t2,…},{n1,n2,…}] gives a multidimensional Fourier coefficient.

FourierCosCoefficient

FourierCosCoefficient[expr,t,n] gives the nth coefficient in the Fourier cosine series expansion of expr.

FourierCosCoefficient[expr,{t1,t2,…},{n1,n2,…}] gives a multidimensional Fourier cosine coefficient.

FourierCosSeries

FourierCosSeries[expr,t,n] gives the nth-order Fourier cosine series expansion of expr in t.

FourierCosSeries[expr,{t1,t2,…},{n1,n2,…}] gives the multidimensional Fourier cosine series of expr.

FourierCosTransform

FourierCosTransform[expr,t,ω] gives the symbolic Fourier cosine transform of expr. 

FourierCosTransform[expr,{t1,t2,…},{ω1,ω2,…}] gives the multidimensional Fourier cosine transform of expr. 

FourierDCT

FourierDCT[list] finds the Fourier discrete cosine transform of a list of real numbers.

FourierDCT[list,m] finds the Fourier discrete cosine transform of type m.

FourierDCTFilter

FourierDCTFilter[image,t] reduces noise in image by locally thresholding the discrete cosine transforms of overlapping subimages, using the hard threshold t.

FourierDCTMatrix

FourierDCTMatrix[n] returns an n×n discrete cosine transform matrix of type 2.

FourierDCTMatrix[n,m] returns an n×n discrete cosine transform matrix of type m.

FourierDST

FourierDST[list] finds the Fourier discrete sine transform of a list of real numbers.

FourierDST[list,m] finds the Fourier discrete sine transform of type m.

FourierDSTMatrix

FourierDSTMatrix[n] returns an n×n discrete sine transform matrix of type 2.

FourierDSTMatrix[n,m] returns an n×n discrete sine transform matrix of type m.

FourierMatrix

FourierMatrix[n] returns an n×n Fourier matrix.

FourierParameters

FourierParameters is an option to Fourier and related functions that specifies the conventions to use in computing Fourier transforms.

FourierSequenceTransform

FourierSequenceTransform[expr,n,ω] gives the Fourier sequence transform of expr.

FourierSequenceTransform[expr,{n1,n2,…},{ω1,ω2,…}] gives the multidimensional Fourier sequence transform. 

FourierSeries

FourierSeries[expr,t,n] gives the nth-order Fourier series expansion of expr in t. 

FourierSeries[expr,{t1,t2,…},{n1,n2,…}] gives the multidimensional Fourier series.

FourierSinCoefficient

FourierSinCoefficient[expr,t,n] gives the nth coefficient in the Fourier sine series expansion of expr.

FourierSinCoefficient[expr,{t1,t2,…},{n1,n2,…}] gives a multidimensional Fourier sine coefficient.

FourierSinSeries

FourierSinSeries[expr,t,n] gives the nth-order Fourier sine series expansion of expr in t.

FourierSinSeries[expr,{t1,t2,…},{n1,n2,…}] gives the multidimensional Fourier sine series of expr.

FourierSinTransform

FourierSinTransform[expr,t,ω] gives the symbolic Fourier sine transform of expr. 

FourierSinTransform[expr,{t1,t2,…},{ω1,ω2,…}] gives the multidimensional Fourier sine transform of expr. 

FourierTransform

FourierTransform[expr,t,ω] gives the symbolic Fourier transform of expr. 

FourierTransform[expr,{t1,t2,…},{ω1,ω2,…}] gives the multidimensional Fourier transform of expr. 

FourierTrigSeries

FourierTrigSeries[expr,t,n] gives the nth-order Fourier trigonometric series expansion of expr in t.

FourierTrigSeries[expr,{t1,t2,…},{n1,n2,…}] gives the multidimensional Fourier trigonometric series of expr.

FoxHReduce

FoxHReduce[expr,x] attempts to reduce expr to a single FoxH object as a function of x.

FractionalBrownianMotionProcess

FractionalBrownianMotionProcess[μ,σ,h] represents fractional Brownian motion process with drift μ, volatility σ, and Hurst index h.

FractionalBrownianMotionProcess[h] represents fractional Brownian motion process with drift 0, volatility 1, and Hurst index h.

FractionalGaussianNoiseProcess

FractionalGaussianNoiseProcess[μ,σ,h] represents a fractional Gaussian noise process with drift μ, volatility σ, and Hurst index h.

FractionalGaussianNoiseProcess[h] represents a fractional Gaussian noise process with drift 0, volatility 1, and Hurst index h.

FractionalPart

FractionalPart[x] gives the fractional part of x. 

FractionLine

FractionLine is an option for fractions that specifies the thickness of the line separating the numerator and denominator.

Frame

Frame is an option for Graphics, Grid, and other constructs that specifies whether to include a frame. 

Framed

Framed[expr] displays a framed version of expr. 

FrameLabel

FrameLabel is an option for Graphics, Manipulate, and related functions that specifies labels to be placed on the edges of a frame. 

FrameListVideo

FrameListVideo[{img1,img2,…}] generates a video containing frames img1, img2, etc.

FrameListVideo[files] generates a video from existing image files.

FrameMargins

FrameMargins is an option for objects that can be displayed with frames which specifies the absolute margins in printer's points to leave inside the frame. 

FrameRate

FrameRate is an option to specify the number of frames per second. 

FrameStyle

FrameStyle is an option for Graphics, Grid, and other constructs that specifies the style in which to draw frames.

FrameTicks

FrameTicks is an option for 2D graphics functions that specifies tick marks for the edges of a frame. 

FrameTicksStyle

FrameTicksStyle is an option for 2D graphics functions that specifies how frame ticks should be rendered.

FRatioDistribution

FRatioDistribution[n,m] represents an F-ratio distribution with n numerator and m denominator degrees of freedom.

FrechetDistribution

FrechetDistribution[α,β] represents the Fréchet distribution with shape parameter α and scale parameter β.

FrechetDistribution[α,β,μ] represents the Fréchet distribution with shape parameter α, scale parameter β, and location parameter μ.

FreeQ

FreeQ[expr,form] yields True if no subexpression in expr matches form, and yields False otherwise. 

FreeQ[expr,form,levelspec] tests only those parts of expr on levels specified by levelspec. 

FreeQ[form] represents an operator form of FreeQ that can be applied to an expression.

FrequencySamplingFilterKernel

FrequencySamplingFilterKernel[{a1,…,ak}] creates a finite impulse response (FIR) filter kernel using a frequency sampling method from amplitude values ai.

FrequencySamplingFilterKernel[{a1,…,ak},m] creates an FIR filter kernel of type m.

FresnelC

FresnelC[z] gives the Fresnel integral C(z). 

FresnelF

FresnelF[z] gives the Fresnel auxiliary function F(z).

FresnelG

FresnelG[z] gives the Fresnel auxiliary function G(z).

FresnelS

FresnelS[z] gives the Fresnel integral S(z). 

Friday

Friday is a day of the week.

FrobeniusNumber

FrobeniusNumber[{a1,…,an}] gives the Frobenius number of a1,…,an.

FrobeniusSolve

FrobeniusSolve[{a1,…,an},b] gives a list of all solutions of the Frobenius equation a1x1+…+anxnb.

FrobeniusSolve[{a1,…,an},b,m] gives at most m solutions.

FromAbsoluteTime

FromAbsoluteTime[time] gives a date object corresponding to an absolute time specification as given by AbsoluteTime.

FromCharacterCode

FromCharacterCode[n] gives a string consisting of the character with integer code n. 

FromCharacterCode[{n1,n2,…}] gives a string consisting of the sequence of characters with codes ni. 

FromCharacterCode[{{n11,n12,…},{n21,…},…}] gives a list of strings. 

FromCharacterCode[codes,"encoding"] uses the specified character encoding. 

FromCoefficientRules

FromCoefficientRules[list,{x1,x2,…}] constructs a polynomial from a list of rules for exponent vectors and coefficients. 

FromContinuedFraction

FromContinuedFraction[list] reconstructs a number from the list of its continued fraction terms. 

FromDate

FromDate[date] converts a date of the form {y,m,d,h,m,s} to an absolute number of seconds since the beginning of January 1, 1900. 

FromDateString

FromDateString["string"] gives a date object corresponding to the date represented by "string".

FromDateString["string",{e1,e2,…}] gives the date object obtained by extracting elements "ei" from "string".

FromDateString["string",fmt] gives the date object obtained using the date format fmt.

FromDigits

FromDigits[list] constructs an integer from the list of its decimal digits. 

FromDigits[list,b] takes the digits to be given in base b. 

FromDigits[list,MixedRadix[blist]] uses the mixed radix with list of bases blist. 

FromDigits["string"] constructs an integer from a string of digits.

FromDigits["string","Roman"] constructs an integer from Roman numerals.

FromDMS

FromDMS[{d,m,s}] converts from degrees, minutes, and seconds to decimal degrees. 

FromDMS["dms"] converts from a DMS string to decimal degrees.

FromDMS["latlon"] converts from a latitude-longitude string to latitude and longitude in decimal degrees.

FromEntity

FromEntity[entity] returns a Wolfram Language object corresponding to an entity.

FromJulianDate

FromJulianDate[jd] gives a date object corresponding to the Julian date jd.

FromJulianDate["type",jd] gives a date object corresponding to the specified Julian date variant.

FromLetterNumber

FromLetterNumber[n] gives the lowercase letter at position n in the English alphabet.

FromLetterNumber[n,alpha] gives the letter at position n in the alphabet specified by alpha.

FromPolarCoordinates

FromPolarCoordinates[{r,θ}] gives the {x,y} Cartesian coordinates corresponding to the polar coordinates {r,θ}. 

FromPolarCoordinates[{r,θ1,…,θn-2,ϕ}] gives the coordinates corresponding to the hyperspherical coordinates {r,θ1,…,θn-2,ϕ} 

FromRomanNumeral

FromRomanNumeral["string"] gives the integer corresponding to the Roman numeral "string". 

FromSphericalCoordinates

FromSphericalCoordinates[{r,θ,ϕ}] gives the {x,y,z} Cartesian coordinates corresponding to the spherical coordinates {r,θ,ϕ}.

FromUnixTime

FromUnixTime[time] gives a date object corresponding to a UnixTime specification.

Full

Full is a setting used for certain options, typically indicating that a full range of values should be included. 

FullAxes

FullAxes[graphics] returns the axes options of a graphics object.

FullDefinition

FullDefinition[symbol] prints as the definitions given for symbol, and all symbols on which these depend.

FullDefinition["symbol"] prints as the definitions given for the symbol named "symbol" if it exists, and all symbols on which these depend.

FullDefinition[patt] prints as the definitions given for the symbols whose names textually match the arbitrary string pattern patt, and all symbols on which these depend.

FullDefinition[{spec1,spec2,…}] prints as the definitions given for the symbols that are equal to or whose names match any of the speci, and all symbols on which these depend.

FullForm

FullForm[expr] prints as the full form of expr, with no special syntax. 

FullGraphics

FullGraphics[g] takes a graphics object, and generates a new one in which objects specified by graphics options are given as explicit lists of graphics primitives. 

FullInformationOutputRegulator

FullInformationOutputRegulator[sys,rspec] gives the full state information output regulator for sys using specification rspec. 

FullInformationOutputRegulator[{sys,{out1,…},{in1,…}},…] specifies the regulated outputs outi and the controlled inputs inj.

FullRegion

FullRegion[n] represents the full region n.

FullSimplify

FullSimplify[expr] tries a wide range of transformations on expr involving elementary and special functions and returns the simplest form it finds. 

FullSimplify[expr,assum] does simplification using assumptions. 

Function

body& or Function[body] is a pure (or "anonymous") function. The formal parameters are # (or #1), #2, etc. 

x|->body or xbody or Function[x,body] is a pure function with a single formal parameter x. 

{x1,x2,…}|->body or {x1,x2,…}body or Function[{x1,x2,…},body] is a pure function with a list of formal parameters. 

Function[params,body,attrs] is a pure function that is treated as having attributes attrs for purposes of evaluation.

FunctionAnalytic

FunctionAnalytic[f,x] tests whether f(x) is an analytic function for x∈Reals.

FunctionAnalytic[f,x,dom] tests whether f(x) is an analytic function for x∈dom.

FunctionAnalytic[{f1,f2,…},{x1,x2,…},dom] tests whether f1(x1,x2,…),f2(x1,x2,…),… are analytic functions for x1,x2,…∈dom.

FunctionAnalytic[{funs,cons},xvars,dom] tests whether funs(xvars) are analytic functions for xvars in an open set containing the solutions of the constraints cons over the domain dom.

FunctionBijective

FunctionBijective[f,x] tests whether f(x)y has exactly one solution x∈Reals for each y∈Reals.

FunctionBijective[f,x,dom] tests whether f(x)y has exactly one solution x∈dom for each y∈dom.

FunctionBijective[{f1,f2,…},{x1,x2,…},dom] tests whether f1(x1,x2,…)y1,f2(x1,x2,…)y2,… has exactly one solution x1,x2,…∈dom for each y1,y2,…∈dom.

FunctionBijective[{funs,xcons,ycons},xvars,yvars,dom] tests whether funs(xvars)yvars has exactly one solution with xvars∈dom restricted by the constraints xcons for each yvars∈dom restricted by the constraints ycons. 

FunctionCompile

FunctionCompile[f] generates a compiled code function from a pure function.

FunctionCompile[{f1,f2,…}] generates a list of compiled code functions from a list of pure functions.

FunctionCompile[<|k1->f1,k2->f2,…|>] generates an association of compiled code functions from an association of Wolfram Language functions.

FunctionCompile[defs,fspec] uses the local auxiliary definitions defs.

FunctionCompileExport

FunctionCompileExport["file.ext",fspec] exports a compiled version of functions fspec in the format specified by the file extension ext.

FunctionCompileExport[path,defs,fspec] exports a compiled version of fspec using local auxiliary definitions defs.

FunctionCompileExport[path,fspec,"format"] exports in the specified format.

FunctionCompileExport[path,defs,fspec,"format"] exports a compiled version using local auxiliary definitions.

FunctionCompileExportByteArray

FunctionCompileExportByteArray[fspec] gives a byte array of binary LLVM code obtained by compiling the function specification fspec.

FunctionCompileExportByteArray[defs,fspec] uses the auxiliary definitions defs for compilation.

FunctionCompileExportByteArray[fspec,"format"] gives a byte array of binary code in the specified format.

FunctionCompileExportLibrary

FunctionCompileExportLibrary[file,fspec] exports a compiled version of function specification fspec as a shared library suitable for external use.

FunctionCompileExportLibrary[file,defs,fspec] uses the auxiliary definitions defs for compilation.

FunctionCompileExportString

FunctionCompileExportString[fspec] gives a string of textual LLVM code obtained by compiling the function specification fspec.

FunctionCompileExportString[defs,fspec] uses the auxiliary definitions defs for compilation.

FunctionCompileExportString[fspec,"format"] gives a string of textual code in the specified format.

FunctionContinuous

FunctionContinuous[f,x] tests whether f(x) is a real-valued continuous function for x∈Reals.

FunctionContinuous[f,x,dom] tests whether f(x) is a continuous function for x∈dom.

FunctionContinuous[{f1,f2,…},{x1,x2,…},dom] tests whether f1(x1,x2,…),f2(x1,x2,…),… are continuous functions for x1,x2,…∈dom.

FunctionContinuous[{funs,cons},xvars,dom] tests whether funs(xvars) are continuous functions for xvars∈dom restricted by the constraints cons. 

FunctionConvexity

FunctionConvexity[f,{x1,x2,…}] finds the convexity of the function f with variables x1,x2,… over the reals.

FunctionConvexity[{f,cons},{x1,x2,…}] finds the convexity when variables are restricted by the constraints cons representing a convex region.

FunctionDeclaration

FunctionDeclaration[name,typedfun] declares name to be a typed function suitable for use in a compiler environment.

FunctionDiscontinuities

FunctionDiscontinuities[f,x] finds the discontinuities of f(x) for x∈Reals. 

FunctionDiscontinuities[f,x,dom] finds the discontinuities of f(x) for x∈dom.

FunctionDiscontinuities[{f1,f2,…},{x1,x2,…},dom] finds the discontinuities of f1(x1,x2,…),f2(x1,x2,…),… for x1,x2,…∈dom.

FunctionDomain

FunctionDomain[f,x] finds the largest domain of definition of the real function f of the variable x. 

FunctionDomain[f,x,dom] considers f to be a function with arguments and values in the domain dom.

FunctionDomain[funs,vars,dom] finds the largest domain of definition of the mapping funs of the variables vars. 

FunctionDomain[{funs,cons},vars,dom] finds the domain of funs with the values of vars restricted by constraints cons.

FunctionExpand

FunctionExpand[expr] tries to expand out special and certain other functions in expr, when possible reducing compound arguments to simpler ones. 

FunctionExpand[expr,assum] expands using assumptions. 

FunctionInjective

FunctionInjective[f,x] tests whether f(x)y has at most one solution x∈Reals for each y.

FunctionInjective[f,x,dom] tests whether f(x)y has at most one solution x∈dom. 

FunctionInjective[{f1,f2,…},{x1,x2,…},dom] tests whether f1(x1,x2,…)y1,f2(x1,x2,…)y2,… has at most one solution x1,x2,…∈dom.

FunctionInjective[{funs,xcons,ycons},xvars,yvars,dom] tests whether funs(xvars)yvars has at most one solution with xvars∈dom restricted by the constraints xcons for each yvars∈dom restricted by the constraints ycons. 

FunctionInterpolation

FunctionInterpolation[expr,{x,xmin,xmax}] evaluates expr with x running from xmin to xmax and constructs an InterpolatingFunction object which represents an approximate function corresponding to the result. 

FunctionInterpolation[expr,{x,xmin,xmax},{y,ymin,ymax},…] constructs an InterpolatingFunction object with several arguments. 

FunctionLayer

FunctionLayer[f] represents a net layer that applies function f to its input.

FunctionMeromorphic

FunctionMeromorphic[f,x] tests whether f(x) is a meromorphic function of x.

FunctionMeromorphic[f,{x1,x2,…}] tests whether f1(x1,x2,…) is a meromorphic function of x1,x2,….

FunctionMeromorphic[{f1,f2,…},{x1,x2,…}] tests whether f1(x1,x2,…),f2(x1,x2,…),… are meromorphic functions for x1,x2,….

FunctionMeromorphic[{funs,cons},xvars] tests whether funs(xvars) are meromorphic functions for xvars in an open set containing the solutions of the constraints cons.

FunctionMonotonicity

FunctionMonotonicity[f,x] finds the monotonicity of the function f with the variable x over the reals.

FunctionMonotonicity[f,x,dom] finds the monotonicity of f when x is restricted to the domain dom.

FunctionMonotonicity[{f,cons},x,dom] gives the monotonicity of f when x is restricted by the constraints cons. 

FunctionPeriod

FunctionPeriod[f,x] gives a period p of the function f over the reals such that f(x+p)f(x).

FunctionPeriod[f,x,dom] gives a period with x restricted to the domain dom.

FunctionPeriod[{f1,f2,…},{x1,x2,…},…] gives periods {p1,p2,…} for {x1,x2,…} such that f(x1+p1,x2+p2,…)f(x1,x2,…).

FunctionPoles

FunctionPoles[f,x] finds the poles of the meromorphic function f with the variable x.

FunctionPoles[{f,cons},x] gives the poles of f when x is restricted by the constraints cons. 

FunctionRange

FunctionRange[f,x,y] finds the range of the real function f of the variable x returning the result in terms of y.

FunctionRange[f,x,y,dom] considers f to be a function with arguments and values in the domain dom.

FunctionRange[funs,xvars,yvars,dom] finds the range of the mapping funs of the variables xvars returning the result in terms of yvars.

FunctionRange[{funs,cons},xvars,yvars,dom] finds the range of the mapping funs with the values of xvars restricted by constraints cons.

FunctionSign

FunctionSign[f,{x1,x2,…}] finds the real sign of the function f with variables x1,x2,… over the reals.

FunctionSign[f,{x1,x2,…},dom] finds the real sign with variables restricted to the domain dom. 

FunctionSign[{f,cons},{x1,x2,…},dom] gives the sign when variables are restricted by the constraints cons. 

FunctionSingularities

FunctionSingularities[f,x] finds the singularities of f(x) for x∈Reals. 

FunctionSingularities[f,x,dom] finds the singularities of f(x) for x∈dom.

FunctionSingularities[{f1,f2,…},{x1,x2,…},dom] finds the singularities of f1(x1,x2,…),f2(x1,x2,…),… for x1,x2,…∈dom.

FunctionSpace

FunctionSpace is an option for FindSequenceFunction and related functions that specifies the space of functions to consider for representations. 

FunctionSurjective

FunctionSurjective[f,x] tests whether f(x)y has at least one solution x∈ for each y∈Reals.

FunctionSurjective[f,x,dom] tests whether f(x)y has at least one solution x∈dom for each y∈dom.

FunctionSurjective[{f1,f2,…},{x1,x2,…},dom] tests whether f1(x1,x2,…)y1,f2(x1,x2,…)y2,… has at least one solution x1,x2,…∈dom for each y1,y2,…∈dom.

FunctionSurjective[{funs,xcons,ycons},xvars,yvars,dom] tests whether funs(xvars)yvars has at least one solution with xvars∈dom restricted by the constraints xcons for each yvars∈dom restricted by the constraints ycons. 

FussellVeselyImportance

FussellVeselyImportance[rdist,t] gives the Fussell–Vesely importances for all components in the ReliabilityDistribution rdist at time t.

FussellVeselyImportance[fdist,t] gives the Fussell–Vesely importances for all components in the FailureDistribution fdist at time t.

GaborFilter

GaborFilter[data,r,k] filters data by convolving with a Gabor kernel of pixel radius r and wave vector k.

GaborFilter[data,r,k,ϕ] uses a Gabor kernel with phase shift ϕ.

GaborFilter[data,{r,σ},…]  uses a Gabor kernel with radius r  and standard deviation σ.

GaborWavelet

GaborWavelet[] represents a Gabor wavelet of frequency 6.

GaborWavelet[w] represents a Gabor wavelet of frequency w.

GainMargins

GainMargins[lsys] gives the gain margins of the linear time-invariant system lsys.

GainPhaseMargins

GainPhaseMargins[lsys] gives the gain and phase margins of the linear time-invariant system lsys.

GalaxyData

GalaxyData[entity,property] gives the value of the specified property for the galaxy entity.

GalaxyData[{entity1,entity2,…},property] gives a list of property values for the specified galaxy entities.

GalaxyData[entity,property,annotation] gives the specified annotation associated with the given property.

GalleryView

GalleryView[{expr1,expr2,…}] represents an object in which the expri are displayed in a browsable gallery layout.

GalleryView[{assoc1,assoc2,…}] uses each of the associations associ to define the display of an item in the gallery.

Gamma

Gamma[z] is the Euler gamma function Γ(z). 

Gamma[a,z] is the incomplete gamma function Γ(a,z). 

Gamma[a,z0,z1] is the generalized incomplete gamma function Γ(a,z0)-Γ(a,z1). 

GammaDistribution

GammaDistribution[α,β] represents a gamma distribution with shape parameter α and scale parameter β.

GammaDistribution[α,β,γ,μ] represents a generalized gamma distribution with shape parameters α and γ, scale parameter β, and location parameter μ.

GammaRegularized

GammaRegularized[a,z] is the regularized incomplete gamma function Q(a,z). 

GapPenalty

GapPenalty is an option for SequenceAlignment and related functions that gives the additional cost associated with each gap corresponding to a run of insertions or deletions.

GARCHProcess

GARCHProcess[κ,{α1,…,αq},{β1,…,βp}] represents a generalized autoregressive conditionally heteroscedastic process of orders p and q, driven by a standard white noise.

GARCHProcess[κ,{α1,…,αq},{β1,…,βp},init] represents a GARCH process with initial data init.

GatedRecurrentLayer

GatedRecurrentLayer[n] represents a trainable recurrent layer that takes a sequence of vectors and produces a sequence of vectors each of size n.

GatedRecurrentLayer[n,opts] includes options for initial weights and other parameters. 

Gather

Gather[list] gathers the elements of list into sublists of identical elements.

Gather[list,test] applies test to pairs of elements to determine if they should be considered identical.

GatherBy

GatherBy[list,f] gathers into sublists each set of elements in list that gives the same value when f is applied.

GatherBy[list,{f1,f2,…}] gathers list into nested sublists using fi at level i. 

GaugeFaceElementFunction

GaugeFaceElementFunction is an option for gauge functions that gives a function to use to generate the primitives for rendering the gauge face.

GaugeFaceStyle

GaugeFaceStyle is an option for gauge functions that specifies the style in which the face is to be drawn.

GaugeFrameElementFunction

GaugeFrameElementFunction is an option for gauge functions that gives a function to generate the primitives for rendering the gauge frame.

GaugeFrameSize

GaugeFrameSize is an option for gauge functions that controls the size of the frame around the gauge.

GaugeFrameStyle

GaugeFrameStyle is an option for gauge functions that specifies the style in which the frame is to be drawn.

GaugeLabels

GaugeLabels is an option for gauge functions that specifies labels to be placed on the gauge.

GaugeMarkers

GaugeMarkers is an option for gauge functions that specifies what markers to draw to mark the values.

GaugeStyle

GaugeStyle is an option for gauge functions that specifies styles in which the markers are to be drawn.

GaussianIntegers

GaussianIntegers is an option for FactorInteger, PrimeQ, Factor, and related functions that specifies whether factorization should be done over Gaussian integers. 

GaussianOrthogonalMatrixDistribution

GaussianOrthogonalMatrixDistribution[σ,n] represents a Gaussian orthogonal matrix distribution with matrix dimensions {n,n} and scale parameter σ.

GaussianOrthogonalMatrixDistribution[n] represents a Gaussian orthogonal matrix distribution with unit scale parameter.

GaussianSymplecticMatrixDistribution

GaussianSymplecticMatrixDistribution[σ,n] represents a Gaussian symplectic matrix distribution with matrix dimensions {2 n,2 n} over the field of complex numbers and scale parameter σ.

GaussianSymplecticMatrixDistribution[n] represents a Gaussian symplectic matrix distribution with unit scale parameter.

GaussianUnitaryMatrixDistribution

GaussianUnitaryMatrixDistribution[σ,n] represents a Gaussian unitary matrix distribution with matrix dimensions {n,n} and scale parameter σ.

GaussianUnitaryMatrixDistribution[n] represents a Gaussian unitary matrix distribution with unit scale parameter.

GaussianWindow

GaussianWindow[x] represents a Gaussian window function of x.

GaussianWindow[x,σ] uses standard deviation σ.

GCD

GCD[n1,n2,…] gives the greatest common divisor of the ni. 

GegenbauerC

GegenbauerC[n,m,x] gives the Gegenbauer polynomial Cn(m)(x). 

GegenbauerC[n,x] gives the renormalized form "lim"+m->0�/m. 

General

General is a symbol to which general system messages are attached. 

GenerateAsymmetricKeyPair

GenerateAsymmetricKeyPair[] randomly generates a PrivateKey and corresponding PublicKey object for use with public-key cryptographic functions.

GenerateAsymmetricKeyPair[type] randomly generates private and public keys of the specified type.

GenerateAsymmetricKeyPair[opts] randomly generates keys using the specified options.

GenerateConditions

GenerateConditions is an option for Integrate, Sum, and similar functions that specifies whether explicit conditions on parameters should be generated in the result.

GeneratedAssetFormat

GeneratedAssetFormat is an option for functions like VideoGenerator that specifies the format of the resulting asset.

GeneratedAssetLocation

GeneratedAssetLocation is an option for functions like VideoGenerator that specifies the location of the resulting asset.

GeneratedDocumentBinding

GeneratedDocumentBinding is an option for supplying parameters to a DocumentGenerator during manual evaluation.

GenerateDerivedKey

GenerateDerivedKey[password] generates a DerivedKey object from the password given.

GenerateDerivedKey[password,salt] generates a DerivedKey object from the password and salt given.

GenerateDigitalSignature

GenerateDigitalSignature[expr,key] generates a digital signature for expr using the specified private key.

GenerateDigitalSignature[key] represents an operator form of GenerateDigitalSignature that can be applied to expressions.

GeneratedParameters

GeneratedParameters is an option that specifies how parameters generated to represent the results of various symbolic operations should be named. 

GeneratedQuantityMagnitudes

GeneratedQuantityMagnitudes is an option that specifies how quantities generated to represent the quantity multiplier results in NondimensionalizationTransform should be named.

GenerateFileSignature

GenerateFileSignature["file",key] generates a digital signature of file using the specified private key.

GenerateFileSignature[{"file",range},key] generates a digital signature of the specified range of bytes in the file.

GenerateFileSignature[{{file1,range1},{file2,range2},…},key] generates digital signatures for each specified filei and rangei.

GenerateFileSignature[key] represents an operator form of GenerateFileSignature that can be applied to files.

GenerateSecuredAuthenticationKey

GenerateSecuredAuthenticationKey[] generates a new anonymous SecuredAuthenticationKey owned by the current user ID.

GenerateSecuredAuthenticationKey["name"] generates a new SecuredAuthenticationKey with the specified name owned by the current user ID.

GenerateSecuredAuthenticationKey[SecuredAuthenticationKey[…]] generates a new set of credentials for an existing SecuredAuthenticationKey.

GenerateSymmetricKey

GenerateSymmetricKey[] randomly generates a SymmetricKey object suitable for use with cryptographic functions.

GenerateSymmetricKey["password"] derives a SymmetricKey object from the password string given.

GenerateSymmetricKey[bytes] generates a SymmetricKey object using the byte array or list of bytes directly as the key.

GenerateSymmetricKey[DerivedKey[…]] generates a symmetric key object with a key given by the DerivedKey object.

GenerateSymmetricKey[opts] randomly generates a symmetric key using the specified options.

GeneratingFunction

GeneratingFunction[expr,n,x] gives the generating function in x for the sequence whose nth series coefficient is given by the expression expr.

GeneratingFunction[expr,{n1,…,nm},{x1,…,xm}] gives the multidimensional generating function in x1,…,xm whose n1,… ,nm coefficient is given by expr.

GeneratorDescription

GeneratorDescription is an option for providing a textual description for a DocumentGenerator.

GeneratorHistoryLength

GeneratorHistoryLength is an option for document generators controlling the number of runs archived in the cloud.

GeneratorOutputType

GeneratorOutputType is an option controlling the file format of documents produced by a DocumentGenerator.

Generic

Generic is a setting for the Mode option of Solve and related functions.

GenericCylindricalDecomposition

GenericCylindricalDecomposition[ineqs,{x1,x2,…}] finds the full-dimensional part of the decomposition of the region represented by the inequalities ineqs into cylindrical parts whose directions correspond to the successive xi, together with any hypersurfaces containing the rest of the region.

GenomeData

GenomeData["gene"] gives the DNA sequence for the specified gene on the reference human genome.

GenomeData["gene","property"] gives the value of the specified property for the human gene gene.

GenomeData[{"chr",{n1,n2}}] gives the sequence from positions n1 to n2 on chromosome chr in the reference human genome.

GenomeLookup

GenomeLookup["seq"] returns the positions of exact matches for the DNA sequence seq on the reference human genome.

GenomeLookup["seq",n] returns at most n matches.

GeoAntipode

GeoAntipode[loc] gives the antipodal position of location loc.

GeoAntipode[g] gives the antipodal primitive of the geo primitive g.

GeoArea

GeoArea[g] gives the area of the geo region g.

GeoArraySize

GeoArraySize is an option for geographic data functions that determines the dimensions of the array generated.

GeoBackground

GeoBackground is an option that specifies the background style of a GeoGraphics object.

GeoBoundary

GeoBoundary[g] returns the boundary line of the geo region g.

GeoBounds

GeoBounds[g] gives the ranges of latitudes and longitudes in the geo region g.

GeoBounds[g,δ] pads ranges of latitudes and longitudes by ±δ.

GeoBounds[g,Scaled[s]] pads range of latitudes and longitudes by a scaled amount s.

GeoBoundsRegion

GeoBoundsRegion[{{latmin,latmax},{lonmin,lonmax}}] is a two-dimensional GeoGraphics primitive that represents a geo region bounded by parallels latmin, latmax and meridians lonmin, lonmax on the surface of the Earth.

GeoBoundsRegion[g] represents the latitude-longitude bounding box of the geo region g.

GeoBoundsRegion[g,δ] pads the ranges of latitudes and longitudes by ±δ.

GeoBoundsRegionBoundary

GeoBoundsRegionBoundary[{{latmin,latmax},{lonmin,lonmax}}] is a one-dimensional GeoGraphics primitive that represents the boundary of the region between parallels latmin, latmax and meridians lonmin, lonmax on the surface of the Earth.

GeoBoundsRegionBoundary[g] represents the boundary of the latitude-longitude bounding box of the geo region g.

GeoBoundsRegionBoundary[g,δ] pads the ranges of latitudes and longitudes by ±δ.

GeoBubbleChart

GeoBubbleChart[{reg1->val1,reg2->val2,…}] makes a geo bubble chart with bubbles centered at the geographic regions regi with sizes vali.

GeoBubbleChart[regions->values] uses a collection of regions regi from regions with corresponding sizes vali from values.

GeoBubbleChart[{data1,data2,…}] plots data from all the datai.

GeoBubbleChart[{…,w[datai],…}] plots datai with features defined by the symbolic wrapper w.

GeoCenter

GeoCenter is an option for GeoGraphics that specifies the coordinates of the point that should appear at the geographic center of the final map.

GeoCircle

GeoCircle[loc,r] is a two-dimensional GeoGraphics primitive that represents a circle of radius r centered at the location loc on the surface of the Earth.

GeoCircle[loc,r,{α1,α2}] represents a sector of a circle from bearing α1 to bearing α2.

GeoContourPlot

GeoContourPlot[{loc1->val1,loc2->val2,…}] makes a geo contour plot from values vali defined at specified locations loci.

GeoContourPlot[locs->vals] uses a collection of locations locs with corresponding values vals.

GeoDensityPlot

GeoDensityPlot[{loc1->val1,loc2->val2,…}] makes a geo density plot with colors at the location loci determined by the value vali.

GeoDensityPlot[locs->vals] uses a collection of locations locs with corresponding values vals.

GeodesicClosing

GeodesicClosing[image,ker] gives the geodesic closing of image with respect to the structuring element ker.

GeodesicClosing[image,r] gives the geodesic closing with respect to a range r square.

GeodesicClosing[data,…] applies geodesic closing to an array of data.

GeodesicDilation

GeodesicDilation[marker,mask] gives the fixed point of the geodesic dilation of the marker constrained by the mask.

GeodesicErosion

GeodesicErosion[marker,mask] gives the fixed point of the geodesic erosion of the marker constrained by the mask.

GeodesicOpening

GeodesicOpening[image,ker] gives the geodesic opening of image with respect to the structuring element ker.

GeodesicOpening[image,r] gives the geodesic opening with respect to a range r square.

GeodesicOpening[data,…] applies geodesic opening to an array of data.

GeoDestination

GeoDestination[loc,{d,α}] gives the end position of the geodesic of length d starting from loc with azimuthal direction α.

GeodesyData

GeodesyData["name","property"] gives the value of the specified property for a named geodetic datum or reference ellipsoid.

GeodesyData[{a,b},"property"] gives the value of the property for the ellipsoid with semimajor axis a and semiminor axis b.

GeodesyData[obj,{"property",coords}] gives the value of the property at the specified coordinates.

GeoDirection

GeoDirection[{lat1,lon1},{lat2,lon2}] gives the azimuthal direction from one latitude-longitude position on the Earth to another.

GeoDirection[loc1,loc2] gives the azimuthal direction between locations specified by position objects or geographic entities.

GeoDisk

GeoDisk[loc,r]  is a two-dimensional GeoGraphics primitive that represents a filled disk of radius r centered at the location loc on the surface of the Earth.

GeoDisk[loc,r,{α1,α2}] gives a sector of a disk from bearing α1 to bearing α2.

GeoDisplacement

GeoDisplacement[{dist,α}] represents a geodesic displacement of length dist and initial bearing α from a geo location.

GeoDisplacement[{dist,α},pathtype] represents a displacement of length dist and initial bearing α along a path of type pathtype.

GeoDisplacement[loc1,loc2,pathtype] returns the displacement needed to reach loc2 from loc1 along a path of type pathtype.

GeoDistance

GeoDistance[{lat1,lon1},{lat2,lon2}] gives the geodesic distance between latitude-longitude positions on the Earth.

GeoDistance[loc1,loc2] gives the distance between locations specified by position objects or geographical entities.

GeoDistance[{loc1,…,locn}] gives the total distance from loc1 to locn through all the intermediate loci.

GeoDistanceList

GeoDistanceList[{loc1,loc2,…,locn}] returns the list of geodesic distances between consecutive pairs of locations.

GeoElevationData

GeoElevationData[] gives the elevation above sea level at $GeoLocation.

GeoElevationData[loc] gives the elevation at the geographic location loc.

GeoElevationData[{loc1,loc2}] gives an array of elevation values within the bounding box given by {loc1,loc2}.

GeoElevationData[GeoPosition[{{lat1,lon1},{lat2,lon2},…}]] gives the list of elevations at the positions {lati,loni}.

GeoElevationData[loc,etype] gives the elevation of type etype for the location loc.

GeoElevationData[loc,etype,format] gives the elevation in the specified format.

GeoEntities

GeoEntities[reg,enttype] gives a list of the geographic entities of type enttype contained in the extended region reg.

GeoEntities[reg] gives a list of the geographic regions of any type contained in reg.

GeoGraphics

GeoGraphics[primitives,options] represents a two-dimensional geographical image.

GeoGraphPlot

GeoGraphPlot[{e1,e2,…}] generates a plot of the geographic graph with edges ei.

GeoGraphPlot[{v1,v2,…},{e1,e2,…}] generates a plot with vertices vi and edges ej.

GeoGraphPlot[{vi->vj,…}] uses rules vi->vj to specify the graph.

GeoGraphPlot[g] displays the graph g with vertices at geographic locations on a map.

GeoGraphPlot[{…,w[ei],…}] plots ei with features defined by the symbolic wrapper w.

GeoGraphValuePlot

GeoGraphValuePlot[{{src1,dest1,flow1},{src2,dest2,flow2},…,{srcn,destn,flown}}] plots the flows between geo locations.

GeoGraphValuePlot[{{e1,val1},{e2,val2},…}] plots the values vali for the edges ei.

GeoGraphValuePlot[g] plots the flow for a graph g with associated edge weights.

GeogravityModelData

GeogravityModelData[] returns the gravitational field data for the current location.

GeogravityModelData[locationspec] returns the gravitational field data for a location.

GeogravityModelData[locationspec,component] returns the component of the gravitational field.

GeoGridDirectionDifference

GeoGridDirectionDifference[proj,loc,β] gives the difference between the angle from north to direction β on the geo grid obtained with projection proj and the actual angle from north to direction β at location loc.

GeoGridDirectionDifference[proj,loc,α->β] gives the difference between projected and unprojected angles from direction α to direction β.

GeoGridLines

GeoGridLines is an option for GeoGraphics that specifies what parallels and meridians to show.

GeoGridLinesStyle

GeoGridLinesStyle is an option for GeoGraphics that specifies how parallels and meridians should be rendered.

GeoGridPosition

GeoGridPosition[{x,y},proj] represents a point {x,y} in a planimetric cartographic grid using the projection proj.

GeoGridPosition[{x,y,h},proj] represents a point {x,y,h} in a cartographic grid with height h with respect to the reference ellipsoid.

GeoGridPosition[{{x1,y1},{x2,y2},…},proj] represents an array of cartographic grid positions.

GeoGridPosition[{x,y,h},proj,datum] represents a point in a cartographic grid obtained by projection from data in the given datum.

GeoGridPosition[entity,proj] returns the cartographic grid position of the specified geographical entity.

GeoGridRange

GeoGridRange is an option for geographic functions that specifies the range of projected coordinates to include.

GeoGridRangePadding

GeoGridRangePadding is an option for geographic functions that specifies how much to extend the projected coordinate ranges determined by GeoGridRange.

GeoGridUnitArea

GeoGridUnitArea[proj,loc] gives the actual geo area corresponding to a unit area on the geo grid obtained with projection proj, evaluated in the limit of small geo regions around location loc.

GeoGridUnitDistance

GeoGridUnitDistance[proj,loc,α] gives the actual geo distance corresponding to a unit distance on the geo grid obtained with projection proj, evaluated in the limit of small displacement from location loc in direction α.

GeoGridVector

GeoGridVector[loc->{vx,vy},proj] represents a horizontal two-dimensional vector of components vx, vy in the orthonormal frame of the coordinates of the geo projection proj, at geo location loc.

GeoGridVector[loc->{vx,vy,vz},proj] represents a three-dimensional vector of horizontal components vx, vy and vertical component vz at geo location loc.

GeoGridVector[{loc1,loc2,…}->{vec1,vec2,…},proj] represents a collection of vectors veci at respective geo locations loci.

GeoGridVector[{loc1->vec1,loc2->vec2,…},proj] represents the same collection of vectors.

GeoGridVector[vec,proj] represents a geo vector whose associated location has been implicitly specified.

GeoGroup

GeoGroup[geoobjects] represents a list of geographic objects to be treated as a single object for certain operations.

GeoHemisphere

GeoHemisphere[] is a two-dimensional GeoGraphics primitive that represents the half of the Earth centered at your current geo location.

GeoHemisphere[loc] represents the half of the Earth centered at the location loc.

GeoHemisphereBoundary

GeoHemisphereBoundary[] is a one-dimensional GeoGraphics primitive that represents the boundary line of a hemisphere of the Earth centered at the current geo location.

GeoHemisphereBoundary[loc] represents the boundary line of a hemisphere centered at the location loc.

GeoHistogram

GeoHistogram[locs] plots a density histogram of the geographic locations locs.

GeoHistogram[locs,bspec] plots a density histogram with bins specified by bspec.

GeoHistogram[locs,bspec,hspec] plots a density histogram with bin densities computed according to the specification hspec.

GeoIdentify

GeoIdentify[enttype] identifies the geographic entities of the type enttype in which the current geo location is contained.

GeoIdentify[enttype,loc] identifies the entities in which the location loc is contained.

GeoIdentify[] identifies the entities of any type in which the current geo location is contained.

GeoImage

GeoImage[reg] gives a satellite image of the geo region reg.

GeoImage[reg,mapstyle] gives an image of the geo region reg with style mapstyle.

GeoLabels

GeoLabels is an option for GeoListPlot and GeoRegionValuePlot that specifies whether and how to add labels to the locations in the first argument.

GeoLength

GeoLength[g] gives the length of the geo path g.

GeoListPlot

GeoListPlot[{loc1,loc2,…}] generates a map on which the locations loci are indicated.

GeoListPlot[{list1,list2,…}]  generates a map showing several lists of locations.

GeoLocation

GeoLocation is an option for Interpreter and related functions that specifies the location to assume for semantic interpretation.

GeologicalPeriodData

GeologicalPeriodData[entity,property] gives the value of the specified property for the geological period entity.

GeologicalPeriodData[{entity1,entity2,…},property] gives a list of property values for the specified period name entities.

GeologicalPeriodData[entity,property,annotation] gives the specified annotation associated with the given property.

GeomagneticModelData

GeomagneticModelData[] returns the current magnetic field data for the current location.

GeomagneticModelData[locationspec] returns the current magnetic field data for a location.

GeomagneticModelData[datespec] returns the magnetic field data for the specified time for the current location.

GeomagneticModelData[locationspec,datespec] returns the magnetic field data for the specified time and location.

GeomagneticModelData[locationspec,datespec,component] returns the component of the magnetic field for the specified time and location.

GeoMarker

GeoMarker[] is a GeoGraphics primitive that represents a marker at the current $GeoLocation.

GeoMarker[loc] is a GeoGraphics primitive that represents a marker at the location loc.

GeoMarker[{loc1,loc2,…}] is a GeoGraphics primitive that represents markers at locations loci.

GeoMarker[loc,marker] is a GeoGraphics primitive that represents a custom marker at the location loc.

GeoMarker[{loc1,loc2,…},marker] is a GeoGraphics primitive that represents custom markers at locations loci.

GeometricAssertion

GeometricAssertion[obj,prop] represents the assertion that the geometric object obj satisfies prop.

GeometricAssertion[{obj1,obj2,…},prop] represents the assertion that the obji satisfy prop.

GeometricAssertion[objs,prop1,prop2,…] represents the assertion that objs satisfies each of the propi.

GeometricBrownianMotionProcess

GeometricBrownianMotionProcess[μ,σ,x0] represents a geometric Brownian motion process with drift μ, volatility σ, and initial value x0.

GeometricDistribution

GeometricDistribution[p] represents a geometric distribution with probability parameter p. 

GeometricMean

GeometricMean[data] gives the geometric mean of the values in data.

GeometricScene

GeometricScene[{p1,p2,…},{hyp1,hyp2,…}] represents an abstract 2D geometric scene defined by the hypotheses hypi in terms of the symbolic points pi.

GeometricScene[{{p1,p2,…},{k1,k2,…}},hyps] represents a scene whose hypotheses depend on the symbolic scalar quantities ki.

GeometricScene[{{p1->{x1,y1},…},{k1->v1,…}},hyps] represents a specific instance with explicit values for all points and scalar quantities.

GeometricScene[params,hyps,{con1,con2,…}] represents a scene together with some conclusions coni about it.

GeometricScene[{{{p1->{x1,y1},…},{k1->v1,…}},…},hyps] represents a collection of specific instances of the same scene.

GeometricScene[{scene1,scene2,…}] combines several scene instances into one scene object.

GeometricStep

GeometricStep[{hyp1,hyp2,…}] gives a symbolic representation of a step in the definition of a geometric scene, in which the hypotheses hypi are introduced. 

GeometricStep[hyps,label] labels the step with label when displaying an instance of the geometric scene.

GeometricTest

GeometricTest[obj,prop] tests whether the geometric object obj satisfies prop.

GeometricTest[{obj1,obj2,…},prop] tests whether the obji satisfy prop.

GeometricTest[objs,prop1,prop2,…] tests whether objs satisfy each of the propi.

GeometricTransformation

GeometricTransformation[g,tfun] represents the result of applying the transformation function tfun to the geometric objects corresponding to the primitives g.

GeometricTransformation[g,m] transforms geometric objects in g by effectively replacing every point r by m.r. 

GeometricTransformation[g,{m,v}] effectively replaces every point r by m.r+v.

GeometricTransformation[g,{t1,t2,…}] represents multiple copies of g transformed by a collection of transformations.

GeoModel

GeoModel is an option for GeoGraphics that specifies the reference body or model for it for the purposes of geodetic computations and map drawing.

GeoNearest

GeoNearest[enttype,loc] returns the geographic entity of type enttype closest to the geo location loc.

GeoNearest[{reg1,reg2,…,regn},loc] returns the nearest of the regi.

GeoNearest[{reg1->val1,reg2->val2,…,regn->valn},loc] returns the vali corresponding to the nearest regi.

GeoNearest[{reg1,reg2,…,regn}->{val1,val2,…,valn},loc] returns the same result.

GeoNearest[{reg1,reg2,…,regn}->Automatic,loc] takes the vali to be successive integers i. 

GeoNearest[spec,loc,n] returns n nearest values.

GeoNearest[spec,loc,{n,r}] returns up to n matches within a radius r of loc.

GeoOrientationData

GeoOrientationData[date,prop] gives the value of the property prop about the orientation of the Earth on the given date.

GeoOrientationData[date,prop,"variant"] gives the specified variant of the property prop on the given date.

GeoPath

GeoPath[{loc1,loc2},pathtype] is a GeoGraphics primitive that represents a path of type pathtype between locations loc1 and loc2.

GeoPath[{loc1,loc2,…},pathtype] represents a path formed by joining paths of type pathtype between consecutive locations loci.

GeoPath[{loc1,d,α},pathtype] represents a path moving from location loc1 a distance d with initial bearing α.

GeoPath[{{loc11,loc12,…},{loc21,…},…},pathtype] represents a disjoint collection of paths of type pathtype.

GeoPolygon

GeoPolygon[{loc1,…,locn}] is a GeoGraphics primitive that represents a filled polygon whose boundary is formed by geodesic segments between locations loci and loci+1.

GeoPolygon[{loc1,…,locn}->{{q1,…,qm},…}] represents a geo polygon with holes {q1,…,qm}, ….

GeoPolygon[{poly1,poly2,…}] represents a collection of polygons polyi.

GeoPolygon[{poly1,poly2,…},sideness] specifies which of the two sides of each boundary polyi is in the interior of the geo polygon.

GeoPolygon[polys,sideness,pathtype] represents a geo polygon whose boundary is formed by geo paths of type pathtype.

GeoPosition

GeoPosition[{lat,lon}] represents a geodetic position with latitude lat and longitude lon.

GeoPosition[{lat,lon,h}] represents a geodetic position with height h relative to the reference ellipsoid.

GeoPosition[{lat,lon,h},datum] represents a geodetic position referring to the specified datum.

GeoPosition[{{lat1,lon1},{lat2,lon2},…},datum] represents an array of geodetic positions.

GeoPosition[entity] returns the geodetic position of the specified geographical entity.

GeoPositionENU

GeoPositionENU[{east,north,up},p]  represents a position with local Cartesian coordinates {east,north,up} in a reference system centered at the position p.

GeoPositionENU[{{e1,n1,u1},{e2,n2,u2},…},p] represents an array of positions.

GeoPositionENU[entity,p] returns the Cartesian position with respect to p of the specified geographical entity.

GeoPositionXYZ

GeoPositionXYZ[{x,y,z}] represents a position in a Cartesian geocentric coordinate system.

GeoPositionXYZ[{x,y,z},datum] represents a point referred to the specified datum.

GeoPositionXYZ[{{x1,y1,z1},{x2,y2,z2},…},datum] represents an array of points in a Cartesian geocentric coordinate system.

GeoPositionXYZ[entity] returns the Cartesian geocentric position of the given geographical entity.

GeoProjection

GeoProjection is an option for GeoGraphics that specifies the cartographic projection to use for the map.

GeoProjectionData

GeoProjectionData["projection","property"] gives the value of the specified property for the specified cartographic projection.

GeoProjectionData["projection"] gives the complete options for the default form of the specified projection.

GeoRange

GeoRange is an option for geographic functions that specifies the range of latitude and longitude to include. 

GeoRangePadding

GeoRangePadding is an option for GeoGraphics that specifies what padding to use when extending beyond the original ranges of latitude and longitude.

GeoRegionValuePlot

GeoRegionValuePlot[{reg1->val1,reg2->val2,…}] generates a plot in which the geographic regions regi are colored according to the values vali.

GeoRegionValuePlot[regions->values] uses a collection of regions regi from regions with corresponding values vali from values.

GeoRegionValuePlot[region->prop] generates a plot in which the geographic subdivisions in region are colored according to the values EntityValue[…,prop].

GeoRegionValuePlot[data] generates a plot using the data available in data.

GeoResolution

GeoResolution is an option for geographic functions that specifies an average distance between neighboring pixels in the resulting map.

GeoScaleBar

GeoScaleBar is an option for GeoGraphics that determines what scale to show on the map.

GeoServer

GeoServer is an option for GeoGraphics, GeoStyling and GeoImage that specifies the URL address of a geo server and connection parameters to download map tiles and geo elevation data.

GeoSmoothHistogram

GeoSmoothHistogram[locs] plots a smooth kernel histogram of the geo locations locs.

GeoSmoothHistogram[locs,espec] plots a smooth kernel histogram with estimator specification espec.

GeoSmoothHistogram[locs,espec,dfun] plots the distribution function dfun.

GeoStreamPlot

GeoStreamPlot[vecs] generates a stream plot from the field of geo vectors vecs.

GeoStreamPlot[{vecs1,vecs2,…}] generates a separate set of streams for each vecsi.

GeoStyling

GeoStyling[mapstyle] displays faces of polygons and other filled geo objects using mapstyle.

GeoStyling[mapstyle,directive] uses mapstyle with the given graphics directive applied.

GeoStylingImageFunction

GeoStylingImageFunction is an option for specifying an image effect to apply to a geo style.

GeoVariant

GeoVariant[obj,qual] represents a geographic object obj with qualifier qual.

GeoVector

GeoVector[loc->{m,α}] represents a horizontal two-dimensional vector of magnitude m and bearing α at geo location loc.

GeoVector[loc->{m,α,w}] represents a three-dimensional vector of horizontal modulus m, bearing α and vertical component w at geo location loc.

GeoVector[{loc1,loc2,…}->{vec1,vec2,…}] represents a collection of vectors veci at respective geo locations loci.

GeoVector[{loc1->vec1,loc2->vec2,…}] represents the same collection of vectors.

GeoVector[vec] represents a geo vector whose associated location has been implicitly specified.

GeoVectorENU

GeoVectorENU[loc->{ve,vn}] represents a horizontal two-dimensional vector of components ve and vn in an orthonormal frame tangent to the Earth at geo location loc.

GeoVectorENU[loc->{ve,vn,vu}] represents a three-dimensional vector of horizontal components ve and vn, and vertical component vu at geo location loc. 

GeoVectorENU[{loc1,loc2,…}->{vec1,vec2,…}] represents a collection of vectors veci at respective geo locations loci.

GeoVectorENU[{loc1->vec1,loc2->vec2,…}] represents the same collection of vectors.

GeoVectorENU[vec] represents a geo vector whose associated location has been implicitly specified.

GeoVectorPlot

GeoVectorPlot[vecs] generates a vector plot from the field of geo vectors vecs.

GeoVectorPlot[{vecs1,vecs2,…}] generates a separate set of vectors for each vecsi.

GeoVectorXYZ

GeoVectorXYZ[loc->{vX,vY,vZ}] represents a three-dimensional vector of Cartesian components vX, vY, vZ in an orthonormal frame parallel to the geocentric frame, at location loc.

GeoVectorXYZ[{loc1,loc2,…}->{vec1,vec2,…}] represents a collection of vectors veci at respective geo locations loci.

GeoVectorXYZ[{loc1->vec1,loc2->vec2,…}] represents the same collection of vectors.

GeoVectorXYZ[vec] represents a geo vector whose associated location has been implicitly specified.

GeoVisibleRegion

GeoVisibleRegion[{lat,lon,h}] is a two-dimensional GeoGraphics primitive that represents the region on the surface of the Earth visible from the point of coordinates lat,lon and height h above the reference ellipsoid.

GeoVisibleRegion[pos] represents the region visible from the position pos.

GeoVisibleRegion[{pos1,pos2,…}] represents the collection of regions visible from the positions posi.

GeoVisibleRegionBoundary

GeoVisibleRegionBoundary[{lat,lon,h}] is a one-dimensional GeoGraphics primitive that represents the boundary of the region on the surface of the Earth visible from the point of coordinates lat,lon and height h above the reference ellipsoid.

GeoVisibleRegionBoundary[pos] represents the boundary of the region visible from the position pos.

GeoVisibleRegionBoundary[{pos1,pos2,…}] represents the collection of boundaries of the regions visible from the positions posi.

GeoWithinQ

GeoWithinQ[reg,loc] returns True if the location loc is contained within the region reg, and False otherwise.

GeoWithinQ[reg] represents an operator form of GeoWithinQ that can be applied to a location.

GeoZoomLevel

GeoZoomLevel is an option for specifying the resolution at which to render a map.

GestureHandler

GestureHandler[expr,{gesture1fun1,gesture2fun2,…}] displays as expr, evaluating funi[value,velocity] whenever "gesturei" occurs within the screen space occupied by expr.

GestureHandler[expr,{"gesture"{fun,funend},…}] evaluates fun as updates are received for "gesture", followed by funend[value,velocity] when the gesture ends.

GestureHandler[expr,{"gesture"{funstart,fun,funend},…}] also evaluates fstart[value,velocity] when "gesture" begins.

Get

<<name reads in a file, evaluating each expression in it and returning the last one. 

Get[stream] reads from a stream, evaluating each expression in it and returning the last one.

Get["file","key"] reads a file that has been encoded using Encode["source","file","key"].

GetContext

GetContext["context`"] loads the file named by ContextToFileName["context`"], which gives the conventional filename for a package that defines "context`".

GetEnvironment

GetEnvironment["var"] gives the setting corresponding to the variable "var" in the operating system environment.

GetEnvironment[{var1,var2,…}] gives a list of rules, corresponding to specified environment variables.

GetEnvironment[] gives information about all existing settings in the operating system environment.

Glaisher

Glaisher is Glaisher's constant with numerical value ≃1.28243. 

GlobalClusteringCoefficient

GlobalClusteringCoefficient[g] gives the global clustering coefficient of the graph g.

GlobalClusteringCoefficient[{v->w,…}] uses rules v->w to specify the graph g. 

Glow

Glow[col] is a graphics directive which specifies that surfaces of 3D graphics objects that follow are to be taken to glow with color col. 

Glow[] specifies that there is no glow. 

GoldenAngle

GoldenAngle is the golden angle (3-@5) π, with numerical value ≃137.5°.

GoldenRatio

GoldenRatio is the golden ratio ϕ1/2 (@5+1), with numerical value ≃1.61803.

GompertzMakehamDistribution

GompertzMakehamDistribution[λ,ξ] represents a Gompertz distribution with scale parameter λ and frailty parameter ξ.

GompertzMakehamDistribution[λ,ξ,θ,α] represents a Gompertz–Makeham distribution with parameters λ, ξ, θ, and α.

GoochShading

GoochShading[] is a three-dimensional graphics directive specifying that surfaces that follow are to be drawn with a warm color facing toward the light and a cool color facing away.

GoochShading[col] uses cool and warm colors obtained by blending col with slate Blue and Orange.

GoochShading[{ccol,wcol}] uses the cool color ccol and the warm color wcol.

GoochShading[{w1,w2}->{ccol,wcol}] uses the colors ccol and wcol weighted by the wi.

GoochShading["scheme"] uses the specified gradient color scheme in ColorData.

GoodmanKruskalGammaTest

GoodmanKruskalGammaTest[v1,v2] tests whether the vectors v1 and v2 are independent.

GoodmanKruskalGammaTest[…,"property"] returns the value of "property".

Goto

Goto[tag] scans for Label[tag], and transfers control to that point. 

Grad

Grad[f,{x1,…,xn}] gives the gradient (∂f/∂x1,…,∂f/∂xn).

Grad[f,{x1,…,xn},chart] gives the gradient in the coordinates chart.

Gradient

Gradient is an option for FindMinimum and related functions that specifies the gradient vector to assume for the function being extremized.

GradientFilter

GradientFilter[data,r] gives the magnitude of the gradient of data, computed using discrete derivatives of a Gaussian of sample radius r.

GradientFilter[data,{r,σ}] uses a Gaussian with standard deviation σ.

GradientFilter[data,{{r1,r2,…},…}] uses a Gaussian with radius ri at level i in data.

GradientFittedMesh

GradientFittedMesh[{p1,p2,…}] gives a MeshRegion whose gradient best fits the normals at points p1,p2,….

GradientOrientationFilter

GradientOrientationFilter[data,r] gives the local orientation parallel to the gradient of data, computed using discrete derivatives of a Gaussian of pixel radius r, returning values between -π/2 and π/2.

GradientOrientationFilter[data,{r,σ}] uses a Gaussian with standard deviation σ.

GrammarApply

GrammarApply[grammar,input] attempts to parse input according to the grammar defined by grammar.

GrammarToken

GrammarToken[form] is a grammar rules pattern object that represents any input of the specified form. 

Graph

Graph[{e1,e2,…}] yields a graph with edges ej.

Graph[{v1,v2,…},{e1,e2,…}] yields the graph with vertices vi and edges ej. 

Graph[{…,wi[vi,…],…},{…,wj[ej,…],…}] yields a graph with vertex and edge properties defined by the symbolic wrappers wk.

Graph[data] yields a graph from data.

Graph3D

Graph3D[g] creates a graph with vertices and edges from the graph g and represented as a 3D plot.

Graph3D[{e1,e2,…}] creates a graph with edges ej and represented as a 3D plot.

Graph3D[{v1,v2,…},{e1,e2,…}] creates a graph with vertices vi and edges ej. 

GraphAssortativity

GraphAssortativity[g] gives the assortativity coefficient of a graph g using vertex degrees.

GraphAssortativity[g,"prop"] gives the assortativity coefficient of the graph g using vertex property "prop".

GraphAssortativity[g,{{vi1,vi2,…},…}] gives the assortativity coefficient of the graph g with respect to the vertex partition {{vi1,vi2,…},…}.

GraphAssortativity[g,{v1,v2,…}->{x1,x2,…}] gives the assortativity coefficient of the graph g using data {x1,x2,…} for vertices {v1,v2,…}.

GraphAssortativity[{v->w,…},…] uses rules v->w to specify the graph g. 

GraphAutomorphismGroup

GraphAutomorphismGroup[g] gives the automorphism group of a graph g.

GraphAutomorphismGroup[{v->w,…}] uses rules v->w to specify the graph g.

GraphCenter

GraphCenter[g] gives the set of vertices with minimum eccentricity in the graph g.

GraphCenter[{v->w,…}] uses rules v->w to specify the graph g.

GraphComplement

GraphComplement[g] gives the graph complement of the graph g.

GraphComplement[{v->w,…}] uses rules v->w to specify the graph g.

GraphData

GraphData[name] gives a graph with the specified name.

GraphData[entity] gives the graph corresponding to the graph entity.

GraphData[entity,property] gives the value of the property for the specified graph entity.

GraphData[class] gives a list of available named graphs in the specified graph class.

GraphData[n] gives a list of available named graphs with n vertices.

GraphDensity

GraphDensity[g] gives the graph density of the graph g.

GraphDensity[{v->w,…}] uses rules v->w to specify the graph g.

GraphDiameter

GraphDiameter[g] gives the greatest distance between any pair of vertices in the graph g.

GraphDiameter[{v->w,…}] uses rules v->w to specify the graph g.

GraphDifference

GraphDifference[g1,g2] gives the graph difference of the graphs g1 and g2.

GraphDifference[{v->w,…},…] uses rules v->w to specify the graph g.

GraphDisjointUnion

GraphDisjointUnion[g1,g2] gives the graph disjoint union of the graphs g1 and g2.

GraphDisjointUnion[g1,g2,…] gives the disjoint union of g1, g2, ….

GraphDisjointUnion[{v->w,…},…] uses rules v->w to specify the graph g.

GraphDistance

GraphDistance[g,s,t] gives the distance from source vertex s to target vertex t in the graph g.

GraphDistance[g,s] gives the distance from s to all vertices of the graph g.

GraphDistance[{v->w,…},…] uses rules v->w to specify the graph g.

GraphDistanceMatrix

GraphDistanceMatrix[g] gives the matrix of distances between vertices for the graph g.

GraphDistanceMatrix[g,d] gives the matrix of distances between vertices of maximal distance d in the graph g.

GraphDistanceMatrix[{v->w,…},…] uses rules v->w to specify the graph g.

GraphEmbedding

GraphEmbedding[g] gives coordinates of the vertices of the graph g.

GraphEmbedding[g,"emb"] gives coordinates of the vertices of the graph g using the embedding "emb".

GraphEmbedding[g,"emb",dim] gives coordinates in dimension dim of the vertices of the graph g using the embedding "emb".

GraphHighlight

GraphHighlight is an option to Graph and related objects that specifies graph elements to highlight. 

GraphHighlightStyle

GraphHighlightStyle is an option to Graph and related objects that specifies styles to use for highlighted graph elements. 

GraphHub

GraphHub[g] gives the set of vertices with maximum vertex degree in the underlying simple graph of g.

GraphHub[g,"In"] gives the set of vertices with maximum vertex in-degree.

GraphHub[g,"Out"] gives the set of vertices with maximum vertex out-degree.

GraphHub[{v->w,…},…] uses rules v->w to specify the graph g.

Graphics

Graphics[primitives,options] represents a two-dimensional graphical image. 

Graphics3D

Graphics3D[primitives,options] represents a three-dimensional graphical image. 

GraphicsArray

GraphicsArray[{g1,g2,…}] represents a row of graphics objects.

GraphicsArray[{{g11,g12,…},…}] represents a two-dimensional array of graphical objects.

GraphicsColumn

GraphicsColumn[{g1,g2,…}] generates a graphic in which the gi are laid out in a column, with g1 above g2, etc. 

GraphicsColumn[list,alignment] aligns each element horizontally in the specified way. 

GraphicsColumn[list,alignment,spacing] leaves the specified spacing between successive elements.

GraphicsComplex

GraphicsComplex[{pt1,pt2,…},data] represents a graphics complex in which coordinates given as integers i in graphics primitives in data are taken to be pti. 

GraphicsGrid

GraphicsGrid[{{g11,g12,…},…}] generates a graphic in which the gij are laid out in a two-dimensional grid.

GraphicsGroup

GraphicsGroup[{g1,g2,…}] represents a collection of graphics objects grouped together for purposes of interactive selection in a notebook. 

GraphicsRow

GraphicsRow[{g1,g2,…}] generates a graphic in which the gi are laid out in a row.

GraphicsRow[list,spacing] leaves the specified spacing between successive elements.

GraphicsSpacing

GraphicsSpacing is an option for GraphicsArray that specifies the spacing between elements in the array. 

GraphIntersection

GraphIntersection[g1,g2] gives the graph intersection of the graphs g1 and g2.

GraphIntersection[g1,g2,…] gives the graph intersection of g1, g2, … .

GraphIntersection[{v->w,…},…] uses rules v->w to specify the graph g.

GraphLayers

GraphLayers is an option for LayeredGraphPlot3D and related functions that specifies layers to draw on the plot.

GraphLayerStyle

GraphLayerStyle is an option for LayeredGraphPlot3D and related functions that specifies the style in which to draw a layer on the plot.

GraphLayout

GraphLayout is an option to Graph and related functions that specifies what layout to use.

GraphLinkEfficiency

GraphLinkEfficiency[g] gives the link efficiency of the graph g.

GraphLinkEfficiency[{v->w,…}] uses rules v->w to specify the graph g.

GraphPeriphery

GraphPeriphery[g] gives vertices that are maximally distant to at least one vertex in the graph g.

GraphPeriphery[{v->w,…}] uses rules v->w to specify the graph g.

GraphPlot

GraphPlot[g] generates a plot of the graph g.

GraphPlot[{e1,e2,…}] generates a plot of the graph with edges ei.

GraphPlot[{…,w[ei],…}] plots ei with features defined by the symbolic wrapper w.

GraphPlot[{vi1->vj1,…}] uses rules vik->vjk to specify the graph g.

GraphPlot[m] uses the adjacency matrix m to specify the graph g.

GraphPlot3D

GraphPlot3D[g] generates a 3D plot of the graph g.

GraphPlot3D[{e1,e2,…}] generates a 3D plot of the graph with edges ei.

GraphPlot3D[{…,w[ei],…}] plots ei with features defined by the symbolic wrapper w.

GraphPlot3D[{vi1->vj1,…}] uses rules vik->vjk to specify the graph g.

GraphPlot3D[m] uses the adjacency matrix m to specify the graph g.

GraphPower

GraphPower[g,n] gives the graph-nth power of the graph g.

GraphPower[{v->w,…},…] uses rules v->w to specify the graph g.

GraphPropertyDistribution

GraphPropertyDistribution[expr,xgdist] represents the distribution of the property expr where the random variable x follows the graph distribution gdist.

GraphPropertyDistribution[expr,{x1gdist1,x2gdist2,…}] represents the distribution where x1, x2, … are independent and follow the graph distributions gdist1, gdist2, ….

GraphQ

GraphQ[g] yields True if g is a valid Graph object and False otherwise.

GraphRadius

GraphRadius[g] gives the minimum eccentricity of the vertices in the graph g.

GraphRadius[{v->w,…}] uses rules v->w to specify the graph g.

GraphReciprocity

GraphReciprocity[g] gives the reciprocity of a graph g.

GraphReciprocity[{v->w,…}] uses rules v->w to specify the graph g.

GraphStyle

GraphStyle is an option to Graph and related objects that specifies styles to use for the different graph elements. 

GraphTree

GraphTree[g] constructs a tree from the tree graph g.

GraphTree[g,root] specifies what vertex to use as the root.

GraphTree[g,root,h] applies h to each vertex to get the corresponding data and ordering of subtrees.

GraphUnion

GraphUnion[g1,g2] gives the graph union of the graphs g1 and g2.

GraphUnion[g1,g2,…] gives the graph union of g1, g2, ….

GraphUnion[{v->w,…},…] uses rules v->w to specify the graph g.

Gray

Gray represents the color gray in graphics or style specifications. 

GrayLevel

GrayLevel[g] represents a color in the grayscale color space with gray level g.

GrayLevel[g,a] specifies opacity a. 

GrayLevel["string"] returns a color from an HTML color name etc.

GrayLevel[color] returns the grayscale representation of color.

Greater

x>y yields True if x is determined to be greater than y. 

x1>x2>x3 yields True if the xi form a strictly decreasing sequence. 

GreaterEqual

x>=y or x≥y yields True if x is determined to be greater than or equal to y. 

x1≥x2≥x3 yields True if the xi form a nonincreasing sequence. 

GreaterEqualLess

GreaterEqualLess[x,y,…] displays as x⋛y⋛….

GreaterEqualThan

GreaterEqualThan[y] is an operator form that yields x≥y when applied to an expression x.

GreaterFullEqual

GreaterFullEqual[x,y,…] displays as x≧y≧….

GreaterGreater

GreaterGreater[x,y,…] displays as x≫y≫….

GreaterLess

GreaterLess[x,y,…] displays as x≷y≷….

GreaterSlantEqual

GreaterSlantEqual[x,y,…] displays as x⩾y⩾….

GreaterThan

GreaterThan[y] is an operator form that yields x>y when applied to an expression x.

GreaterTilde

GreaterTilde[x,y,…] displays as x≳y≳….

Green

Green represents the color green in graphics or style specifications. 

GreenFunction

GreenFunction[{ℒ[u[x]],ℬ[u[x]]},u,{x,xmin,xmax},y] gives a Green's function for the linear differential operator ℒ with boundary conditions ℬ in the range xmin to xmax. 

GreenFunction[{ℒ[u[x1,x2,…]],ℬ[u[x1,x2,…]]},u,{x1,x2,…}∈Ω,{y1,y2,…}] gives a Green's function for the linear partial differential operator ℒ over the region Ω.

GreenFunction[{ℒ[u[x,t]],ℬ[u[x,t]]},u,{x,xmin,xmax},t,{y,τ}] gives a Green's function for the linear time-dependent operator ℒ in the range xmin to xmax.

GreenFunction[{ℒ[u[x1,…,t]],ℬ[u[x1,…,t]]},u,{x1,…}∈Ω,t,{y1,…,τ}] gives a Green's function for the linear time-dependent operator ℒ over the region Ω.

Grid

Grid[{{expr11,expr12,…},{expr21,expr22,…},…}] is an object that formats with the exprij arranged in a two-dimensional grid. 

GridFrame

GridFrame is an option for grids that specifies whether a surrounding frame is drawn.

GridFrameMargins

GridFrameMargins is an option for grids that specifies the spacing between the content of the grid and the frame surrounding it.

GridGraph

GridGraph[{m,n}] gives the grid graph with m×n vertices Gm,n.

GridGraph[{n1,n2,…,nk}] gives the k-dimensional grid graph with n1×n2×⋯×nk vertices Gn1,n2,…,nk.

GridLines

GridLines is an option for two-dimensional graphics functions that specifies grid lines. 

GridLinesStyle

GridLinesStyle is an option for 2D graphics functions that specifies how grid lines should be rendered.

GridVideo

GridVideo[{v1,v2,…}] creates a video in which each frame is a grid of frames of all vi at the corresponding time.

GridVideo[{{v11,v12,…},…}] uses the array position of each video vij to create the video grid.

GroebnerBasis

GroebnerBasis[{poly1,poly2,…},{x1,x2,…}] gives a list of polynomials that form a Gröbner basis for the set of polynomials polyi. 

GroebnerBasis[{poly1,poly2,…},{x1,x2,…},{y1,y2,…}] finds a Gröbner basis in which the yi have been eliminated. 

GroupActionBase

GroupActionBase is an option to specify a base for a group.

GroupBy

GroupBy[{elem1,elem2,…},f] gives an association that groups the elemi into lists associated with distinct keys f[elemi].

GroupBy[{elem1,elem2,…},fk->fv] groups the fv[elemi] according to the fk[elemi].

GroupBy[{elem1,elem2,…},{fs1,fs2,…}] groups into nested associations using fsi at level i.

GroupBy[{elem1,elem2,…},spec,red] applies the function red to reduce lists of values that are generated.

GroupBy[spec] represents an operator form of GroupBy that can be applied to an expression.

GroupCentralizer

GroupCentralizer[group,g] returns the centralizer of the element g in group.

GroupElementFromWord

GroupElementFromWord[group,w] returns the element of group determined by the word w in the generators of group.

GroupElementPosition

GroupElementPosition[group,g] returns the position of the element g in the list of elements of group.

GroupElementPosition[group,{g1,…,gn}] returns the list of positions of the elements g1,…,gn in group.

GroupElementQ

GroupElementQ[group,g] returns True if the object g is an element of group and False otherwise.

GroupElements

GroupElements[group] returns the list of all elements of group.

GroupElements[group,{r1,…,rk}] returns the elements numbered r1,…,rk in group in the standard order.

GroupElementToWord

GroupElementToWord[group,g] decomposes the group element g as a product of generators of group.

GroupGenerators

GroupGenerators[group] returns a list of generators of group. 

Groupings

Groupings[n,k] gives a list of all possible groupings of 1,…,n taken k at a time. 

Groupings[{a1,…,an},k] gives all possible groupings of a1,…,an taken k at a time.

Groupings[{{a1,a2,…},{b1,b2,…},…},k] gives the combination of all possible groupings of each of the lists ai,bi,… taken k at a time.

Groupings[aspec,f->k] gives all possible groupings of aspec taken k at a time with the function f applied at each level. 

Groupings[aspec,{f1->k1,f2->k2,…}] gives all possible groupings in which the function fi is applied to ki elements. 

Groupings[aspec,{{f1->k1,m1},{f2->k2,m2},…}] allows at most mi occurrences in a given grouping of fi applied to ki elements.

Groupings[aspec,kspec,h] wraps the function h around each grouping generated.

GroupMultiplicationTable

GroupMultiplicationTable[group] gives the multiplication table of group as an array.

GroupOrbits

GroupOrbits[group,{p1,…}] returns the orbits of the points pi under the action of the elements of group.

GroupOrbits[group,{p1,…},f] finds the orbits under the group action given by a function f.

GroupOrder

GroupOrder[group] returns the number of elements of group.

GroupPageBreakWithin

GroupPageBreakWithin is an option for Cell that specifies whether a page break should be allowed within the group of cells if the notebook that contains the group is printed. 

GroupSetwiseStabilizer

GroupSetwiseStabilizer[group,{p1,…,pn}] returns the subgroup of group for which the images of the points pi are still in the list {p1,…,pn}.

GroupSetwiseStabilizer[group,{p1,…,pn},f] returns the setwise stabilizer subgroup under the action given by the function f.

GroupStabilizer

GroupStabilizer[group,{p1,…,pn}] returns the subgroup of elements of group that move none of the points p1, …, pn.

GroupStabilizer[group,{p1,…,pn},f] returns the stabilizer subgroup under the action given by the function f.

GroupStabilizerChain

GroupStabilizerChain[group] returns a list of successive stabilizers in group of the points in a base of group.

GrowCutComponents

GrowCutComponents[image,{marker1,marker2,…}] creates a segmentation from image by growing each markeri. 

GrowCutComponents[video,…] returns segmentation for each frame in video.

Gudermannian

Gudermannian[z] gives the Gudermannian function gd(z).

GuidedFilter

GuidedFilter[image,guide,r,ϵ] filters image using the guide image guide over range-r neighborhoods with pixel-value regularizer ϵ.

GuidedFilter[image,r,ϵ] filters image so as to reduce noise, using image as the guide.

GumbelDistribution

GumbelDistribution[α,β] represents a Gumbel distribution with location parameter α and scale parameter β.

GumbelDistribution[] represents a Gumbel distribution with location parameter 0 and scale parameter 1.

HaarWavelet

HaarWavelet[] represents a Haar wavelet. 

HadamardMatrix

HadamardMatrix[n] returns an n×n Hadamard matrix.

HalfLine

HalfLine[{p1,p2}] represents the half-line from the point p1 through p2. 

HalfLine[p,v] represents the half-line from the point p in the direction v. 

HalfNormalDistribution

HalfNormalDistribution[θ] represents a half-normal distribution with scale inversely proportional to parameter θ.

HalfPlane

HalfPlane[{p1,p2},w] represents the half-plane bounded by the line through p1 and p2 and extended in the direction w.

HalfPlane[p,v,w] represents the half-plane bounded by the line through p along v and extended in the direction w. 

HalfSpace

HalfSpace[n,p] represents the half-space of points x such that n.(x-p)≤0.

HalfSpace[n,c] represents the half-space of points x such that n.x≤c. 

HalftoneShading

HalftoneShading[] is a three-dimensional graphics directive specifying that surfaces that follow are to be drawn with a base pattern of dots.

HalftoneShading[d] uses the density d of shading.

HalftoneShading[col] uses dots with the specified color col.

HalftoneShading["shape"] uses the specified "shape" as base pattern. 

HalftoneShading[d,col,"shape"] uses a fixed pattern of "shape" with the specified color col and density d.

HamiltonianGraphQ

HamiltonianGraphQ[g] yields True if the graph g is Hamiltonian, and False otherwise.

HammingDistance

HammingDistance[u,v] gives the Hamming distance between strings or vectors u and v.

HammingDistance[u,v] gives the Hamming distance between strings, vectors or biomolecular sequences u and v.

HammingWindow

HammingWindow[x] represents a Hamming window function of x.

HandlerFunctions

HandlerFunctions is an option that specifies functions to apply when events are generated.

HandlerFunctionsKeys

HandlerFunctionsKeys is an option that specifies the content of associations to which to apply handler functions. 

HankelH1

HankelH1[n,z] gives the Hankel function of the first kind Hn(1)(z). 

HankelH2

HankelH2[n,z] gives the Hankel function of the second kind Hn(2)(z). 

HankelMatrix

HankelMatrix[n] gives the n×n Hankel matrix with first row and first column being successive integers.

HankelMatrix[{c1,c2,…,cn}] gives the Hankel matrix whose first column consists of entries c1, c2, ….

HankelMatrix[{c1,c2,…,cm},{r1,r2,…, rn}] gives the Hankel matrix with entries ci down the first column, and ri across the last row.

HankelTransform

HankelTransform[expr,r,s] gives the Hankel transform of order 0 for expr.

HankelTransform[expr,r,s,ν] gives the Hankel transform of order ν for expr.

HannPoissonWindow

HannPoissonWindow[x] represents a Hann–Poisson window function of x.

HannPoissonWindow[x,α] uses the parameter α.

HannWindow

HannWindow[x] represents a Hann window function of x.

HannWindow[x,α] uses the parameter α.

HaradaNortonGroupHN

HaradaNortonGroupHN[] represents the sporadic simple Harada–Norton group HN.

HararyGraph

HararyGraph[k,n] generates the minimal k-connected graph on n vertices Hk,n.

HarmonicMean

HarmonicMean[data] gives the harmonic mean of the values in data.

HarmonicNumber

HarmonicNumber[n] gives the nth harmonic number Hn.

HarmonicNumber[n,r] gives the harmonic number Hn(r) of order r. 

Hash

Hash[expr] gives an integer hash code for the expression expr.

Hash[expr,type] gives an integer hash digest of the specified type for expr.

Hash[expr,type,"format"] gives a hash code in the specified format.

HatchFilling

HatchFilling[] is a two-dimensional graphics directive that specifies that faces of polygons and other filled graphics objects are to be drawn using closely spaced parallel lines. 

HatchFilling["name"] uses the specified line hatching "name".

HatchFilling[θ] draws parallel lines with an angle θ.

HatchFilling[θ,r] draws parallel lines with absolute thickness r. 

HatchFilling[θ,r,d] draws parallel lines with gaps of absolute thickness d. 

HatchShading

HatchShading[] is a three-dimensional graphics directive specifying that objects that follow are to be drawn with closely spaced parallel lines.

HatchShading[d] uses the density d of shading.

HatchShading[col] uses lines with the specified color col. 

HatchShading[d,col] uses lines with the specified color col and density d.

Haversine

Haversine[z] gives the haversine function hav(z).

HazardFunction

HazardFunction[dist,x] gives the hazard function for the distribution dist evaluated at x.

HazardFunction[dist,{x1,x2,…}] gives the multivariate hazard function for the distribution dist evaluated at {x1,x2,…}.

HazardFunction[dist] gives the hazard function as a pure function.

Head

Head[expr] gives the head of expr. 

Head[expr,h] wraps the result with h.

HeadCompose

HeadCompose[a, b, c, d] gives a[b][c][d].

HeaderAlignment

HeaderAlignment is an option for Dataset that specifies how the contents of a header should be aligned within the available area in the header.

HeaderBackground

HeaderBackground is an option for Dataset that specifies what background color to use for row and column headers.

HeaderDisplayFunction

HeaderDisplayFunction is an option for Dataset that specifies a function to apply to headers before displaying them.

HeaderLines

HeaderLines is an option for SemanticImport and related functions that specifies how many of the initial rows should be considered part of a column header.

HeaderSize

HeaderSize is an option for Dataset that specifies the widths and heights of headers.

HeaderStyle

HeaderStyle is an option for Dataset that specifies the style to use for headers.

Heads

Heads is an option for functions which use level specifications that specifies whether heads of expressions should be included. 

HeatFluxValue

HeatFluxValue[pred,vars,pars] represents a thermal heat flux boundary condition for PDEs with predicate pred indicating where it applies, with model variables vars and global parameters pars.

HeatFluxValue[pred,vars,pars,lkey] represents a thermal heat flux boundary condition with local parameters specified in pars[lkey].

HeatInsulationValue

HeatInsulationValue[pred,vars,pars] represents a thermal insulation boundary condition for PDEs with predicate pred indicating where it applies, with model variables vars and global parameters pars.

HeatInsulationValue[pred,vars,pars,lkey] represents a thermal insulation boundary condition with local parameters specified in pars[lkey].

HeatOutflowValue

HeatOutflowValue[pred,vars,pars] represents a thermal outflow boundary condition for PDEs with predicate pred indicating where it applies, with model variables vars and global parameters pars.

HeatOutflowValue[pred,vars,pars,lkey] represents a thermal outflow boundary condition with local parameters specified in pars[lkey].

HeatRadiationValue

HeatRadiationValue[pred,vars,pars] represents a thermal radiation boundary condition for PDEs with predicate pred indicating where it applies, with model variables vars and global parameters pars.

HeatRadiationValue[pred,vars,pars,lkey] represents a thermal radiation boundary condition with local parameters specified in pars[lkey].

HeatSymmetryValue

HeatSymmetryValue[pred,vars,pars] represents a thermal symmetry boundary condition for PDEs with predicate pred indicating where it applies, with model variables vars and global parameters pars.

HeatSymmetryValue[pred,vars,pars,lkey] represents a thermal symmetry boundary condition with local parameters specified in pars[lkey].

HeatTemperatureCondition

HeatTemperatureCondition[pred,vars,pars] represents a thermal surface boundary condition for PDEs with predicate pred indicating where it applies, with model variables vars and global parameters pars.

HeatTemperatureCondition[pred,vars,pars,lkey] represents a thermal surface boundary condition with local parameters specified in pars[lkey].

HeatTransferPDEComponent

HeatTransferPDEComponent[vars,pars] yields a heat transfer PDE term with variables vars and parameters pars.

HeatTransferValue

HeatTransferValue[pred,vars,pars] represents a thermal transfer boundary condition for PDEs with predicate pred indicating where it applies, with model variables vars and global parameters pars.

HeatTransferValue[pred,vars,pars,lkey] represents a thermal transfer boundary condition with local parameters specified in pars[lkey].

HeavisideLambda

HeavisideLambda[x] represents the triangle distribution Λ(x) which is nonzero for x<1.

HeavisideLambda[x1,x2,…] represents the multidimensional triangle distribution Λ(x1,x2,…) which is nonzero for xi<1.

HeavisidePi

HeavisidePi[x] represents the box distribution Π(x), equal to 1 for x<1/2 and 0 for x>1/2.

HeavisidePi[x1,x2,…] represents the multidimensional box distribution Π(x1,x2,…) which is 1 if all xi<1/2.

HeavisideTheta

HeavisideTheta[x] represents the Heaviside theta function θ(x), equal to 0 for x<0 and 1 for x>0. 

HeavisideTheta[x1,x2,…] represents the multidimensional Heaviside theta function, which is 1 only if all of the xi are positive. 

HeldGroupHe

HeldGroupHe[] represents the sporadic simple Held group He.

HelmholtzPDEComponent

HelmholtzPDEComponent[vars,pars] yields a Helmholtz PDE term ∇2{x1,…,xn}u+k2u with model variables vars and model parameters pars.

HelpBrowserSettings

HelpBrowserSettings is a global option that specifies settings for the legacy Help Browser.

Here

Here represents the current deduced geo location.

HermiteDecomposition

HermiteDecomposition[m] gives the Hermite normal form decomposition of an integer matrix m.

HermiteH

HermiteH[n,x] gives the Hermite polynomial Hn(x). 

Hermitian

Hermitian[{1,2}] represents the symmetry of a Hermitian matrix.

HermitianMatrixQ

HermitianMatrixQ[m] gives True if m is explicitly Hermitian, and False otherwise. 

HessenbergDecomposition

HessenbergDecomposition[m] gives the Hessenberg decomposition of a numerical matrix m.

HeunB

HeunB[q,α,γ,δ,ϵ,z] gives the bi-confluent Heun function. 

HeunBPrime

HeunBPrime[q,α,γ,δ,ϵ,z] gives the z-derivative of the HeunB function. 

HeunC

HeunC[q,α,γ,δ,ϵ,z] gives the confluent Heun function.

HeunCPrime

HeunCPrime[q,α,γ,δ,ϵ,z] gives the z-derivative of the HeunC function. 

HeunD

HeunD[q,α,γ,δ,ϵ,z] gives the double-confluent Heun function. 

HeunDPrime

HeunDPrime[q,α,γ,δ,ϵ,z] gives the z-derivative of the HeunD function. 

HeunG

HeunG[a,q,α,β,γ,δ,z] gives the general Heun function. 

HeunGPrime

HeunGPrime[a,q,α,β,γ,δ,z] gives the z-derivative of the HeunG function. 

HeunT

HeunT[q,α,γ,δ,ϵ,z] gives the tri-confluent Heun function. 

HeunTPrime

HeunTPrime[q,α,γ,δ,ϵ,z] gives the z-derivative of the HeunT function. 

HexadecimalCharacter

HexadecimalCharacter represents a hexadecimal digit character 0–9, a–f, A–F in StringExpression.

Hexahedron

Hexahedron[{p1,p2,…,p8}] represents a filled hexahedron with corners p1, p2, …, p8.

Hexahedron[{{p1,1,p1,2,…,p1,8},{p2,1,…},…}] represents a collection of hexahedra.

HiddenItems

HiddenItems is an option for Dataset that specifies which items to hide.

HiddenMarkovProcess

HiddenMarkovProcess[i0,m,em] represents a discrete-time, finite-state hidden Markov process with transition matrix m, emission matrix em, and initial hidden state i0.

HiddenMarkovProcess[…,m,{dist1,…}] represents a hidden Markov process with emission distributions disti.

HiddenMarkovProcess[p0,m,…] represents a hidden Markov process with initial hidden state probability vector p0.

HiddenSurface

HiddenSurface is an option for SurfaceGraphics which specifies whether hidden surfaces are to be eliminated. 

Highlighted

Highlighted[expr] displays a highlighted version of expr.

Highlighted[expr,effect] uses the effect effect to highlight plot elements representing expr.

HighlightGraph

HighlightGraph[g,{a1,a2,…}] highlights the ai that can be vertices, edges, or subgraphs of g.

HighlightGraph[g,{…,wj[aj],…}] highlights using the symbolic wrappers wj.

HighlightGraph[{v->w,…},…] uses rules v->w to specify the graph g.

HighlightImage

HighlightImage[image,roi] highlights the specified region of interest roi in image.

HighlightImage[image,{roi1,roi2,…}] highlights several regions of interest roii.

HighlightImage[image,{…,w[roii],…}] highlights using a feature defined by the symbolic wrapper w.

HighlightImage[image,fg,bgstyle] applies the styling bgstyle to the complement of all the regions of interest.

HighpassFilter

HighpassFilter[data,ωc] applies a highpass filter with a cutoff frequency ωc to an array of data.

HighpassFilter[data,ωc,n] uses a filter kernel of length n.

HighpassFilter[data,ωc,n,wfun] applies a smoothing window wfun to the filter kernel.

HigmanSimsGroupHS

HigmanSimsGroupHS[] represents the sporadic simple Higman–Sims group HS.

HilbertCurve

HilbertCurve[n] gives the line segments representing the nth-step Hilbert curve.

HilbertCurve[n,d] gives the nth-step Hilbert curve in dimension d.

HilbertFilter

HilbertFilter[data,ωc] applies a Hilbert filter with a cutoff frequency ωc to an array of data.

HilbertFilter[data,ωc,n] uses a filter kernel of length n.

HilbertFilter[data,ωc,n,wfun] applies a smoothing window wfun to the filter kernel.

HilbertMatrix

HilbertMatrix[n] gives the n×n Hilbert matrix with elements of the form 1/(i+j-1).

HilbertMatrix[{m,n}] gives the m×n Hilbert matrix.

Histogram

Histogram[{x1,x2,…}] plots a histogram of the values xi.

Histogram[{x1,x2,…},bspec] plots a histogram with bin width specification bspec.

Histogram[{x1,x2,…},bspec,hspec] plots a histogram with bin heights computed according to the specification hspec.

Histogram[{data1,data2,…},…] plots histograms for multiple datasets datai.

Histogram3D

Histogram3D[{{x1,y1},{x2,y2},…}] plots a 3D histogram of the values {xi,yi}.

Histogram3D[{{x1,y1},{x2,y2},…},bspec] plots a 3D histogram with bins specified by bspec.

Histogram3D[{{x1,y1},{x2,y2},…},bspec,hspec] plots a 3D histogram with bin heights computed according to the specification hspec.

Histogram3D[{data1,data2,…}] plots 3D histograms for multiple datasets datai.

HistogramDistribution

HistogramDistribution[{x1,x2,…}] represents the probability distribution corresponding to a histogram of the data values xi.

HistogramDistribution[{{x1,y1,…},{x2,y2,…},…}] represents a multivariate histogram distribution based on data values {xi,yi,…}.

HistogramDistribution[…,bspec] represents a histogram distribution with bins specified by bspec.

HistogramList

HistogramList[{x1,x2,…}] gives a list of bins and histogram heights of the values xi.

HistogramList[{{x1,y1,…},{x2,y2,…},…}] gives a list of bins and histogram heights of the values {xi,yi,…}.

HistogramList[…,bspec] gives a list of bins and histogram heights with bins specified by bspec.

HistogramList[…,bspec,hspec] gives a list of bins and histogram heights with bin heights computed according to the specification hspec.

HistogramPointDensity

HistogramPointDensity[pdata] estimates the histogram point density function μ(x) for point data pdata. 

HistogramPointDensity[pdata,bspec] estimates the histogram point density function μ(x) with histogram bins specified by bspec.

HistogramPointDensity[bdata,…,…] estimates the histogram point density function μ(x) for binned data bdata. 

HistogramPointDensity[pproc,…,…] computes the histogram point density function μ(x) for the point process pproc.

HistogramTransform

HistogramTransform[image] transforms pixel values of image so that its histogram is nearly flat.

HistogramTransform[image,ref] modifies pixel values of image so that its histogram would have nearly the same distribution as ref.

HistogramTransform[image,ref,n] uses n equally spaced quantiles.

HistogramTransform[{x1,x2,…},…] transforms values xi.

HistogramTransformInterpolation

HistogramTransformInterpolation[{x1,x2,…}] finds a function f so that the transformed values f(xi) are distributed nearly uniformly.

HistogramTransformInterpolation[{x1,x2,…},ref] finds f so that f(xi) are distributed with distribution ref.

HistogramTransformInterpolation[{x1,x2,…},ref,n] finds a function with n equally spaced quantiles.

HistogramTransformInterpolation[image,…] finds a function that reshapes the histogram of image.

HistoricalPeriodData

HistoricalPeriodData[entity,property] gives the value of the specified property for the historical period entity.

HistoricalPeriodData[{entity1,entity2,…},property] gives a list of property values for the specified historical period entities.

HistoricalPeriodData[entity,property,annotation] gives the specified annotation associated with the given property.

HitMissTransform

HitMissTransform[image,ker] gives the hit-or-miss transform of image with respect to the composite structuring element ker.

HitMissTransform[image,{ker1,ker2,…}] gives the union of the hit-or-miss transforms for all the structuring elements keri.

HitMissTransform[image,{ker1,ker2,…},t] treats values above t as foreground.

HITSCentrality

HITSCentrality[g] gives a list of authority and hub centralities for the vertices in the graph g.

HITSCentrality[{v->w,…}] uses rules v->w to specify the graph g.

HjorthDistribution

HjorthDistribution[m,s,f] represents the Hjorth distribution with location parameter m, scale parameter s, and shape parameter f.

HodgeDual

HodgeDual[tensor] gives the Hodge dual of the tensor

HodgeDual[tensor,dim] dualizes tensor in the slots with dimension dim

HodgeDual[tensor,dim,slots] dualizes tensor in the given slots.

HoeffdingDTest

HoeffdingDTest[v1,v2] tests whether the vectors v1 and v2 are independent.

HoeffdingDTest[…,"property"] returns the value of "property".

Hold

Hold[expr] maintains expr in an unevaluated form. 

HoldAll

HoldAll is an attribute that specifies that all arguments to a function are to be maintained in an unevaluated form. 

HoldAllComplete

HoldAllComplete is an attribute which specifies that all arguments to a function are not to be modified or looked at in any way in the process of evaluation. 

HoldComplete

HoldComplete[expr] shields expr completely from the standard Wolfram Language evaluation process, preventing even upvalues associated with expr from being used. 

HoldFirst

HoldFirst is an attribute that specifies that the first argument to a function is to be maintained in an unevaluated form. 

HoldForm

HoldForm[expr] prints as the expression expr, with expr maintained in an unevaluated form. 

HoldPattern

HoldPattern[expr] is equivalent to expr for pattern matching, but maintains expr in an unevaluated form. 

HoldRest

HoldRest is an attribute which specifies that all but the first argument to a function are to be maintained in an unevaluated form. 

HolidayCalendar

HolidayCalendar is an option that specifies the holiday calendar schedule in business day functions.

HornerForm

HornerForm[poly] puts the polynomial poly in Horner form.

HornerForm[poly,vars] puts poly in Horner form with respect to the variable or variable list vars.

HornerForm[poly1/poly2] puts the rational function poly1/poly2 in Horner form by nesting poly1 and poly2.

HornerForm[poly1/poly2,vars1,vars2] puts poly1/poly2 in Horner form using the variables or variable lists vars1 and vars2 for poly1 and poly2, respectively.

HostLookup

HostLookup[name] gives the IP address for the host with the specified name.

HostLookup[address] gives the host name for the host at the specified IP address.

HostLookup[spec,prop] gives a specified property of the host.

HostLookup[spec,All] gives an association of properties found for the host.

HotellingTSquareDistribution

HotellingTSquareDistribution[p,m] represents Hotelling's T2 distribution with dimensionality parameter p and m degrees of freedom.

HoytDistribution

HoytDistribution[q,ω] represents a Hoyt distribution with shape parameter q and spread parameter ω.

HTTPErrorResponse

HTTPErrorResponse[code] is an object that represents an error response to an HTTP request, with specified error code.

HTTPRedirect

HTTPRedirect[uri] represents an HTTP redirect to the specified uri.

HTTPRedirect[uri,metadata] represents an HTTP redirect to uri with the specified metadata.

HTTPRequest

HTTPRequest[url] represents an HTTP request for the specified URL.

HTTPRequest[assoc] represents an HTTP request built from the components in the association assoc. 

HTTPRequest[url,assoc] represents an HTTP request for the specified URL with additional elements such as headers given by assoc.

HTTPRequestData

HTTPRequestData["prop"] gives the value of the specified property of the current HTTP request.

HTTPRequestData[] gives an association with values of properties of the current HTTP request.

HTTPResponse

HTTPResponse[body] is an object that represents a successful response to an HTTP request, with the specified body and default metadata.

HTTPResponse[body,metadata] represents a response to an HTTP request, including the specified body and metadata.

Hue

Hue[h] represents a color in the HSB color space with hue h. 

Hue[h,s,b] specifies colors in terms of hue, saturation and brightness. 

Hue[h,s,b,a] specifies opacity a. 

Hue["string"] returns a color from an HTML color name etc.

Hue[color] returns the HSB representation of color.

HumanGrowthData

HumanGrowthData[spec] returns the range of values within one standard deviation of the mean for all properties of human growth at the specification spec.

HumanGrowthData[spec,property] returns the range of values within one standard deviation of the mean of a property for the specification spec.

HumanGrowthData[spec,index] returns the values for all properties of human growth for spec at the specified percentile.

HumanGrowthData[spec,property,index] returns the value at a specific index of a property for spec at the specified percentile.

HumanGrowthData[spec,property,quantity] returns the percentile and probability density for a specific value quantity of the property at spec.

HumpDownHump

HumpDownHump[x,y,…] displays as x≎y≎….

HumpEqual

HumpEqual[x,y,…] displays as x≏y≏….

HurwitzLerchPhi

HurwitzLerchPhi[z,s,a] gives the Hurwitz–Lerch transcendent Φ(z,s,a).

HurwitzZeta

HurwitzZeta[s,a] gives the Hurwitz zeta function ζ(s,a).

HyperbolicDistribution

HyperbolicDistribution[α,β,δ,μ] represents a hyperbolic distribution with location parameter μ, scale parameter δ, shape parameter α, and skewness parameter β.

HyperbolicDistribution[λ,α,β,δ,μ] represents a generalized hyperbolic distribution with shape parameter λ.

HypercubeGraph

HypercubeGraph[n] gives the n-dimensional hypercube graph Qn.

HyperexponentialDistribution

HyperexponentialDistribution[{α1,…,αm},{λ1,…,λm}] represents an m-phase hyperexponential distribution with phase probabilities αi and rates λi.

Hyperfactorial

Hyperfactorial[n] gives the hyperfactorial function H(n).

Hypergeometric0F1

Hypergeometric0F1[a,z] is the confluent hypergeometric function 0F1(;a;z). 

Hypergeometric0F1Regularized

Hypergeometric0F1Regularized[a,z] is the regularized confluent hypergeometric function 0F1(;a;z)/Γ(a). 

Hypergeometric1F1

Hypergeometric1F1[a,b,z] is the Kummer confluent hypergeometric function 1F1(a;b;z). 

Hypergeometric1F1Regularized

Hypergeometric1F1Regularized[a,b,z] is the regularized confluent hypergeometric function 1F1(a;b;z)/Γ(b). 

Hypergeometric2F1

Hypergeometric2F1[a,b,c,z] is the hypergeometric function 2F1(a,b;c;z). 

Hypergeometric2F1Regularized

Hypergeometric2F1Regularized[a,b,c,z] is the regularized hypergeometric function 2F1(a,b;c;z)/Γ(c). 

HypergeometricDistribution

HypergeometricDistribution[n,nsucc,ntot] represents a hypergeometric distribution.

HypergeometricPFQ

HypergeometricPFQ[{a1,…,ap},{b1,…,bq},z] is the generalized hypergeometric function pFq(a;b;z). 

HypergeometricPFQRegularized

HypergeometricPFQRegularized[{a1,…,ap},{b1,…,bq},z] is the regularized generalized hypergeometric function pFq(a;b;z)/(Γ(b1)…Γ(bq)). 

HypergeometricU

HypergeometricU[a,b,z] is the Tricomi confluent hypergeometric function U(a,b,z). 

Hyperlink

Hyperlink[uri] represents a hyperlink that jumps to the specified URI when clicked. 

Hyperlink[label,uri] represents a hyperlink to be displayed as label. 

Hyperplane

Hyperplane[n,p] represents the hyperplane with normal n passing through the point p.

Hyperplane[n,c] represents the hyperplane with normal n given by the points x that satisfy n.xc. 

Hyphenation

Hyphenation is an option for Cell that specifies whether to allow hyphenation for words of text. 

HypoexponentialDistribution

HypoexponentialDistribution[{λ1,…,λm}] represents an m-phase hypoexponential distribution with rates λ1, …, λm.

HypothesisTestData

HypothesisTestData[…] represents hypothesis test data such as generated by DistributionFitTest, AndersonDarlingTest, etc. 

I

I represents the imaginary unit @-1. 

IconData

IconData[type,value] generates an icon of the specified type assuming the value given. 

Iconize

Iconize[expr] gives an iconized form that can be used to stand in for expr in notebook input.

Iconize[expr,"name"] displays with the specified name in the icon.

IconRules

IconRules is an option for CloudObject and related objects that specifies icons to use in different environments to represent an object.

Icosahedron

Icosahedron[] represents a regular icosahedron centered at the origin with unit edge length.

Icosahedron[l] represents an icosahedron with edge length l.

Icosahedron[{θ,ϕ},…] represents an icosahedron rotated by an angle θ with respect to the z axis and angle ϕ with respect to the y axis.

Icosahedron[{x,y,z},…] represents an icosahedron centered at {x,y,z}.

Identity

Identity[expr] gives expr (the identity operation). 

IdentityMatrix

IdentityMatrix[n] gives the nn identity matrix. 

IdentityMatrix[{m,n}] gives the mn identity matrix. 

If

If[condition,t,f] gives t if condition evaluates to True, and f if it evaluates to False. 

If[condition,t,f,u] gives u if condition evaluates to neither True nor False. 

IgnoreCase

IgnoreCase is an option for string manipulation and searching functions that specifies whether lowercase and uppercase letters should be treated as equivalent. 

IgnoreDiacritics

IgnoreDiacritics is an option for string, grammar, and related functions that specifies whether diacritics should be ignored in strings.

IgnoreIsotopes

IgnoreIsotopes is an option for MoleculeMatchQ that determines whether isotopes should be ignored for pattern matching.

IgnorePunctuation

IgnorePunctuation is an option for AlphabeticSort and related functions that specifies whether to consider punctuation in determining sorting order.

IgnoreStereochemistry

IgnoreStereochemistry is an option for MoleculeMatchQ that determines whether stereochemistry should be ignored for pattern matching.

IgnoringInactive

IgnoringInactive[patt] is a pattern object that, for purposes of pattern matching, ignores occurrences of Inactive in both patt and the expression being matched.

Im

Im[z] gives the imaginary part of the complex number z. 

Image

Image[data] represents a raster image with pixel values given by the array data.

Image[graphics] creates a raster image from a graphics object. 

Image[obj,options] gives an image that uses the specified options.

Image3D

Image3D[data] represents a 3D image with pixel values given by the array data.

Image3D[{image1,image2,…}] creates a 3D image from a list of 2D images.

Image3D[obj,"type"] creates a 3D image of the specified data type.

Image3DProjection

Image3DProjection[image] takes a 3D image and returns a 2D image of maximum projection onto the x-y plane.

Image3DProjection[image,dir] performs a projection in the direction specified by dir.

Image3DProjection[image,dir,mode] specifies the projection mode.

ImageAccumulate

ImageAccumulate[image] gives an image in which each pixel represents a sum of all pixels below and to the left of that pixel in image.

ImageAdd

ImageAdd[image,x] adds an amount x to each channel value in image.

ImageAdd[image1,image2] gives an image in which each pixel is the sum of the corresponding pixels in image1 and image2.

ImageAdd[image,expr1,expr2,…] adds all expri to image, where each expri can be either an image, a number, or a color value.

ImageAdjust

ImageAdjust[image] adjusts the levels in image, rescaling them to cover the range 0 to 1.

ImageAdjust[image,corr] adjusts the image according to the correction specification corr.

ImageAdjust[image,corr,{inmin,inmax}] first rescales so that the range of input values inmin to inmax is mapped to 0 to 1.

ImageAdjust[image,corr,{inmin,inmax},{outmin,outmax}] rescales so that the range of input values inmin to inmax is mapped to outmin to outmax.

ImageAlign

ImageAlign[ref,image] returns a version of image that is aligned with the reference image ref.

ImageAlign[ref,{image1,…,imagen}] gives the result of aligning each of the imagei with the reference image ref.

ImageAlign[{image1,…,imagen}] uses image1 as the reference image.

ImageApply

ImageApply[f,image] applies the function f to the list of channel values for each pixel in image.

ImageApply[f,{image1,image2,…}] applies f to the sequence of corresponding pixel values taken from each imagei.

ImageApplyIndexed

ImageApplyIndexed[f,image] applies the function f to the list of channel values for each pixel in image, giving the row and column index of each pixel as a second argument to f.

ImageApplyIndexed[f,{image1,image2,…}] applies f to the sequence of corresponding pixel values taken from each imagei, giving the corresponding row and column index of pixels as the last argument to f.

ImageAspectRatio

ImageAspectRatio[image] gives the ratio of height to width for image.

ImageAspectRatio[video] gives the aspect ratio of video frames.

ImageAssemble

ImageAssemble[{{im11,…,im1n},…,{imm1,…,immn}}] assembles a single image from an array of images.

ImageAssemble[{{im11,…,im1n},…,{imm1,…,immn}},fitting] assembles images using the fitting method.

ImageAugmentationLayer

ImageAugmentationLayer[{h,w}] represents a net layer that applies random image transformations to produce images of height h and width w.

ImageCapture

ImageCapture[] opens a graphical user interface for capturing images from connected cameras.

ImageCaptureFunction

ImageCaptureFunction is an option for ImageCapture that specifies the function to apply to images acquired by the imaging device. 

ImageCases

ImageCases[image] gives an association of lists of subimages for each identified category of objects in image.

ImageCases[image,category] gives a list of subimages identified as an instance of the specified category.

ImageCases[image,category->prop] gives the specified property prop for each identified subimage.

ImageCases[image,{category1,category2,…}] gives an association with lists of subimages identified as being instances of each of the categoryi.

ImageCases[video,…] gives a time series of detected objects in frames of video.

ImageChannels

ImageChannels[image] gives the number of channels present in the data for the Image or Image3D object image.

ImageChannels[video] gives the number of channels present in frames of a video.

ImageClip

ImageClip[image] clips all channel values in image to lie in the default range.

ImageClip[image,{min,max}] clips channel values to lie in the range from min to max.

ImageClip[image,{min,max},{vmin,vmax}] gives vmin for values below min and vmax for values above max.

ImageCollage

ImageCollage[{image1,image2,…}] creates a collage of images imagei.

ImageCollage[{w1->image1,w2->image2,…}] creates a collage of images imagei based on their corresponding weights wi.

ImageCollage[<|image1->w1,image2->w2,…|>] also creates a collage of images imagei based on their corresponding weights wi.

ImageCollage[{w1,w2,…}->{image1,image2,…}] also creates a collage of images imagei based on their corresponding weights wi.

ImageCollage[{{image1,w1},{image2,w2},…}] also creates a collage of images imagei based on their corresponding weights wi.

ImageCollage[…,fitting] uses the fitting method to create the collage.

ImageCollage[…,fitting,size] creates a collage of the specified size.

ImageColorSpace

ImageColorSpace[image] gives the name of the color space of image.

ImageCompose

ImageCompose[image,overlay] gives the result of overlaying overlay onto image. 

ImageCompose[image,{overlay,α}] gives the result of alpha blending overlay into image using blending fraction α.

ImageCompose[image,overlay,pos] places the center of overlay at position pos in image.

ImageCompose[image,overlay,pos,opos] places the point opos in overlay at position pos in image.

ImageCompose[image,overlay,pos,opos,{fi,fo,mode}] uses the compositing fractions fk and the specified compositing mode.

ImageContainsQ

ImageContainsQ[image,category] returns True if an instance of the specified category is detected in image.

ImageContainsQ[image,{category1,category2,…}] returns True if at least one instance of each of the categoryi is detected in image.

ImageContainsQ[image,category1|category2|…] returns True if image contains an instance of at least one of categoryi.

ImageContainsQ[video,…] returns a time series of Boolean values for every frame of video.

ImageContents

ImageContents[image] gives a dataset of identified entities in image.

ImageContents[image,category] gives a dataset that only contains entities in the specified category.

ImageContents[image,category,prop] includes the properties prop for each identified object.

ImageContents[video,…] gives a time series of detected objects in frames of video.

ImageConvolve

ImageConvolve[image,ker] gives the convolution of image with kernel ker.

ImageCooccurrence

ImageCooccurrence[image,n] gives the n×n co-occurrence matrix for image.

ImageCooccurrence[image,n,ker] computes a co-occurrence matrix for arbitrary spatial relationships specified by a kernel ker.

ImageCorners

ImageCorners[image] finds corners in image and returns their coordinates.

ImageCorners[image,r] finds corners at a pixel range r.

ImageCorners[image,r,t] uses a threshold t for selecting corners.

ImageCorners[image,r,t,d] returns corners that are at least d+1 pixels apart.

ImageCorners[video,…] returns corners in frames of video.

ImageCorrelate

ImageCorrelate[image,ker] gives the correlation of image with kernel ker.

ImageCorrelate[image,ker,f] computes a generalized correlation in which the function f is used in place of Dot.

ImageCorrespondingPoints

ImageCorrespondingPoints[image1,image2] finds a set of matching interest points in image1 and image2 and returns their pixel coordinates.

ImageCrop

ImageCrop[image] crops image by removing borders of uniform color. 

ImageCrop[image,size] crops image based on the size specification size.

ImageCrop[image,size,spec] crops image by removing pixels from sides specified by spec.

ImageCrop[video,…] crops frames of video.

ImageData

ImageData[image] gives the array of pixel values in an Image or Image3D object image.

ImageData[image,"type"] gives the array of pixel values converted to the specified type.

ImageDeconvolve

ImageDeconvolve[image,ker] gives a deconvolution of image using kernel ker.

ImageDemosaic

ImageDemosaic[image,cfa] reconstructs a color image using the specified color filter array cfa.

ImageDemosaic[image,{"cfa",{row,col}}] aligns the top-left pixel of the pattern with the {row,col} pixel of image.

ImageDifference

ImageDifference[image1,image2] gives an image in which each pixel is the absolute difference of the corresponding pixels in image1 and image2. 

ImageDimensions

ImageDimensions[image] gives the pixel dimensions of an Image or Image3D object image.

ImageDimensions[video] gives the pixel dimensions of the first video track of the Video object video.

ImageDisplacements

ImageDisplacements[{image1,image2,…,imagen}] gives estimated horizontal and vertical displacements between consecutive images.

ImageDisplacements[{image1,image2,…,imagen},flow] uses flow as an initial estimate for displacement between image1 and image2.

ImageDistance

ImageDistance[image1,image2] returns a distance measure between image1 and image2. 

ImageDistance[image1,image2,pos] places the center of image2 at position pos in image1.

ImageDistance[image1,image2,pos1,pos2] places the point pos2 of image2 at position pos1 in image1.

ImageEffect

ImageEffect[image,"effect"] applies the specified image effect to image.

ImageEffect[image,{"effect",params}] uses parameters params.

ImageEffect[video,…] applies the image effect to frames of video.

ImageExposureCombine

ImageExposureCombine[{image1,image2,…}] combines differently exposed images imagei of the same scene into a single image with overall good exposure.

ImageExposureCombine[{image1,image2,…},mode] creates a low or a high dynamic range image based on the specified mode.

ImageFeatureTrack

ImageFeatureTrack[{image1,image2,…,imagen}] tracks features from image1 through imagen.

ImageFeatureTrack[{image1,image2,…,imagen},pts] tracks features starting from the initial set of points pts in image1.

ImageFileApply

ImageFileApply[f,inputfile,outputfile] applies the function f to the list of channel values for each pixel of the image stored in inputfile and stores the result in outputfile.

ImageFileFilter

ImageFileFilter[f,inputfile,r,outputfile] applies the function f to the range r neighborhood of each pixel in each channel of the image stored in inputfile and stores the result in outputfile.

ImageFileScan

ImageFileScan[f,inputfile] applies the function f to the list of channel values for each pixel of the image stored in inputfile.

ImageFilter

ImageFilter[f,image,r] applies the function f to the range-r neighborhood of each pixel in each channel of image.

ImageFocusCombine

ImageFocusCombine[{image1,image2,…}] combines differently focused images imagei of the same scene to obtain a single well-focused image. 

ImageForestingComponents

ImageForestingComponents[image] finds a segmentation of image, returning an integer matrix in which positive integers label different components.

ImageForestingComponents[image,marker] tries to find a segmentation into components that include pixels indicated by marker.

ImageForestingComponents[image,marker,r] finds components that are connected at a pixel scale given by r.

ImageForestingComponents[video,…] computes components for each frame in video.

ImageForwardTransformation

ImageForwardTransformation[image,f] gives an image in which each pixel at position f[{x,y}] corresponds to the position {x,y} in image.

ImageForwardTransformation[image,f,size] gives an image of the specified size.

ImageForwardTransformation[video,…] transforms frames of a video.

ImageGraphics

ImageGraphics[image] returns the content of image in the form of scalable vector graphics.

ImageGraphics[image,n] uses up to n colors for the vector graphics.

ImageGraphics[image,colors] creates vector graphics containing the specified colors.

ImageHistogram

ImageHistogram[image] plots a histogram of the pixel levels for each channel in image.

ImageHistogram[image,bspec] uses bin specification bspec.

ImageHistogram[image,bspec,range] plots the histogram of the pixel values in the given range.

ImageIdentify

ImageIdentify[image] yields the result of attempting to identify what image is a picture of. 

ImageIdentify[image,category] restricts the identification of image to objects within the specified category.

ImageIdentify[image,category,n] gives a list of up to n possible identifications.

ImageIdentify[image,category,n,"prop"] gives the specified property for each identification.

ImageInstanceQ

ImageInstanceQ[image,obj] gives True if image appears to be an instance of the object obj, and gives False otherwise.

ImageInstanceQ[image,obj,cat] assumes that the image is of something in the category cat.

ImageKeypoints

ImageKeypoints[image] finds key features in image and returns their coordinates.

ImageKeypoints[image,prop] gives the specified property prop for each keypoint.

ImageKeypoints[video,…] finds keypoints in frames of video.

ImageLabels

ImageLabels is an option for image highlighting that specifies what labels to use for each highlighted feature.

ImageLegends

ImageLegends is an option for image highlighting that specifies what legends to use.

ImageLevels

ImageLevels[image] gives a list of pixel values and counts for each channel in image. 

ImageLevels[image,bspec] bins pixel values using bin specification bspec.

ImageLevels[image,bspec,range] gives counts for bins in the given range.

ImageLines

ImageLines[image] finds line segments in image and returns the coordinates of their endpoints.

ImageLines[image,t] uses the threshold t for selecting image lines.

ImageLines[image,t,d] uses the parameter d to control the distinctness of the detected lines.

ImageLines[video,…] finds lines in frames of video.

ImageMargins

ImageMargins is an option that specifies the absolute margins to leave around the image displayed for an object. 

ImageMarker

ImageMarker[pos] is a HighlightImage specification that represents a marker at position pos.

ImageMarker[pos,marker] represents a custom marker at position pos.

ImageMarker[{pos1,pos2,…},…] represents multiple marker positions posi.

ImageMeasurements

ImageMeasurements[image,"prop"] returns the value of property "prop" for the entire image.

ImageMeasurements[image,"prop",format] returns the values in the specified output format.

ImageMeasurements[{image1, image2, …},…] returns measurements for all imagei.

ImageMesh

ImageMesh[image] returns the foreground region in image as a BoundaryMeshRegion object.

ImageMultiply

ImageMultiply[image,x] multiplies each channel value in image by a factor x.

ImageMultiply[image1,image2] gives an image in which each pixel is the product of the corresponding pixels in image1 and image2.

ImageMultiply[image,expr1,expr2,…] multiplies all expri with image, where each expri can be either an image, a number, or a color value.

ImagePad

ImagePad[image,m] pads image on all sides with m background pixels.

ImagePad[image,m,padding] pads image on all sides using the value or method specified by padding.

ImagePad[image,{{left,right},{bottom,top}},…] pads image with the specified numbers of pixels on each side.

ImagePad[image,{{left,right},{front,back},{bottom,top}},…] pads a 3D image with the specified numbers of pixels.

ImagePad[video,…] pads frames of video.

ImagePadding

ImagePadding is an option for graphics functions that specifies what absolute extra padding should be left for extended objects such as thick lines and annotations such as tick and axis labels.

ImagePartition

ImagePartition[image,s] partitions an image into an array of ss-pixel subimages.

ImagePartition[image,{w,h}] partitions an image into an array of subimages of pixel width w and pixel height h.

ImagePartition[image,{w,h},{dw,dh}] uses pixel offsets dw and dh.

ImagePeriodogram

ImagePeriodogram[image] shows the squared magnitude of the discrete Fourier transform (power spectrum) of image.

ImagePeriodogram[image,n] shows the average of power spectra of non-overlapping partitions of size n×n.

ImagePeriodogram[image,n,d] uses partitions with offset d.

ImagePeriodogram[image,n,d,wfun] applies a smoothing window wfun to each partition.

ImagePeriodogram[image,n,d,wfun,m] pads partitions with zeros to length m prior to the computation of the transform.

ImagePerspectiveTransformation

ImagePerspectiveTransformation[image,m] applies a linear fractional transform specified by a matrix m to the positions of each pixel in image.

ImagePerspectiveTransformation[image,tf] uses the TransformationFunction given by tf.

ImagePerspectiveTransformation[image,…,size] gives an image of the specified size.

ImagePerspectiveTransformation[video,…] transforms frames of a video.

ImagePosition

ImagePosition[image] gives an association of image positions for each identified category of objects in image.

ImagePosition[image,obj] gives a list of image positions for subimages identified as instances of the specified category.

ImagePosition[video,…] gives a time series of detected object positions in frames of video.

ImagePreviewFunction

ImagePreviewFunction is an option for CurrentImage and similar functions that specifies the function to apply to images before being displayed.

ImagePyramid

ImagePyramid[image] creates a Gaussian image pyramid formed from image.

ImagePyramid[image,pyrtype] returns a Gaussian or Laplacian pyramid depending of the specified pyrtype.

ImagePyramid[image,pyrtype,n] returns up to n levels of the pyramid.

ImagePyramid[image,pyrtype,{size}] returns pyramid levels down to image dimensions given by size.

ImagePyramid[image,pyrtype,n,s] returns a pyramid with successive levels downsampled by factor s.

ImagePyramidApply

ImagePyramidApply[f,pyr] applies f to all images in the ImagePyramid object pyr.

ImagePyramidApply[f,{pyr1,pyr2,…}] applies f to the sequence of corresponding levels taken from each pyri.

ImageQ

ImageQ[image] yields True if image has the form of a valid Image or Image3D object, and False otherwise.

ImageRecolor

ImageRecolor[image,region->color] recolors pixels in image specified by region using the specified color.

ImageRecolor[image,{region1->color1,…}] recolors multiple regions.

ImageRecolor[video,…] recolors frames of a video.

ImageReflect

ImageReflect[image] reverses image by top-bottom mirror reflection. 

ImageReflect[image,side] reverses image by reflecting it so that the specified side goes to the opposite side.

ImageReflect[image,side1->side2] reflects image so that side1 is interchanged with side2.

ImageReflect[video,…] reflects frames of video.

ImageResize

ImageResize[image,width] gives a resized version of image that is width pixels wide.

ImageResize[image,{size}] gives a resized version of image with a maximum pixel width or height given by size.

ImageResize[image,{width,height}] gives a resized version of image that has exactly the specified pixel width and height.

ImageResize[video,…] gives a video in which every frame is resized.

ImageResize[image,{width,depth,height}] gives a resized version of a 3D image with the specified dimensions.

ImageResolution

ImageResolution is an option for Export, Rasterize, and related functions that specifies at what resolution bitmap images should be rendered. 

ImageRestyle

ImageRestyle[image,sample] attempts to restyle image so as to follow the graphical style of sample. 

ImageRestyle[image,w->sample] uses restyle weighting w. 

ImageRestyle[image,{sample1,…}] attempts to restyle image using a blend of the graphical styles of the samplei.

ImageRestyle[image,{w1->sample1,…}] uses weightings wi for the samplei.

ImageRotate

ImageRotate[image] rotates image by 90° about its center in the x-y plane. 

ImageRotate[image,θ] rotates image by θ radians.

ImageRotate[image,{θ,w}] rotates a 3D image around the 3D vector w.

ImageRotate[image,…,size] gives an image of the specified size.

ImageRotate[video,…] rotate frames of video.

ImageRotated

ImageRotated is an option for Export that specifies whether images should be rotated into landscape mode. 

ImageSaliencyFilter

ImageSaliencyFilter[image] returns a saliency map for image.

ImageScaled

ImageScaled[{x,y}] gives the position of a graphical object in terms of coordinates scaled to run from 0 to 1 across the whole image region in each direction. 

ImageScaled[{dx,dy},{x0,y0}] gives a position obtained by starting at ordinary coordinates {x0,y0}, then moving by an image‐scaled offset {dx,dy}. 

ImageScan

ImageScan[f,image] evaluates f applied to each pixel of image in turn.

ImageSize

ImageSize is an option that specifies the overall size of an image to display for an object. 

ImageSizeAction

ImageSizeAction is an option for Pane and related constructs that specifies what to do if the specified ImageSize setting does not match the size of the contents.

ImageSizeMultipliers

ImageSizeMultipliers is an option that specifies how much smaller to render graphics that appear within other constructs.

ImageStitch

ImageStitch[{image1,image2,…}] gives a composed image from an unordered list of imagei.

ImageStitch[{{image11,image12,…},{image21,image22,…},…}] returns a stitched image from a matrix of images imageij, according to their array position.

ImageStitch[images,canvas] projects the stitched image onto the geometry specified by canvas.

ImageSubtract

ImageSubtract[image,x] subtracts a constant amount x from each channel value in image.

ImageSubtract[image1,image2] gives an image in which each pixel is obtained by subtracting the values of the corresponding pixels in image1 and image2.

ImageSubtract[image,expr1,expr2,…] subtracts all expri from image, where each expri can be either an image, a number, or a color value.

ImageTake

ImageTake[image,n] gives an image consisting of the first n rows of image.

ImageTake[image,-n] gives an image consisting of the last n rows of image.

ImageTake[image,{row1,row2}] gives rows row1 through row2.

ImageTake[image,{row1,row2},{col1,col2}] gives the image that spans row1 to row2 and col1 to col2.

ImageTake[video,…] returns a video in which every frame consists of the specified region of interest.

ImageTake[image3d,{slice1,slice2},{row1,row2},{col1,col2}] gives the 3D image consisting of the specified slices, rows, and columns.

ImageTransformation

ImageTransformation[image,f] gives an image in which each pixel at position p corresponds to the position f[p] in image.

ImageTransformation[image,f,size] gives an image of the specified size.

ImageTransformation[video,…] transforms frames of a video.

ImageTrim

ImageTrim[image,roi] gives the smallest subimage of image that includes the specified region of interest roi.

ImageTrim[image,roi,r] adds a margin of size r back to the resulting image.

ImageTrim[image,{roi1,roi2,…},…] extracts multiple subimages specified by roii from image.

ImageTrim[video,…] extracts the subimages from video.

ImageType

ImageType[image] gives the underlying type of values used for each pixel element in the Image or Image3D object image.

ImageValue

ImageValue[image,pos] gives the interpolated value of image at position pos.

ImageValue[image,pos,"type"] gives the value converted to the specified type.

ImageValuePositions

ImageValuePositions[image,val] returns a list of pixel positions in image that exactly match the value val.

ImageValuePositions[image,val,d] returns all pixel positions that have values within a distance d from val.

ImageVectorscopePlot

ImageVectorscopePlot[image] plots the chrominance of image.

ImageWaveformPlot

ImageWaveformPlot[image] plots the waveform of image.

ImageWaveformPlot[image,colorspace] plots the waveform of image in colorspace.

ImageWaveformPlot[image,channel] plots the waveform for the specified channel.

ImagingDevice

ImagingDevice is an option to specify what device to use for capturing images.

ImplicitRegion

ImplicitRegion[cond,{x1,…,xn}] represents a region in n that satisfies the conditions cond. 

ImplicitRegion[cond,{{x1,a1,b1},…}] represents a region in n that satisfies the conditions cond as well as a1≤x1≤b1 etc.

Implies

Implies[p,q] represents the logical implication p⇒q. 

Import

Import[source] imports data from source, returning a Wolfram Language representation of it.

Import[source,"fmt"] takes the file to be in the specified format "fmt".

Import[source,elements] imports the specified elements from a file.

Import[source,…,options] uses the specified options.

ImportByteArray

ImportByteArray[ba,"format"] imports data in the specified format from a ByteArray object.

ImportByteArray[ba,elements] imports the specified elements.

ImportByteArray[ba] attempts to determine the format automatically.

ImportedObject

ImportedObject[…] represents a piece of imported data that has no special representation in the Wolfram Language. 

ImportOptions

ImportOptions is an option for Interpreter and related functions that specifies what options should be used in importing data.

ImportString

ImportString["data","format"] imports data in the specified format from a string. 

ImportString["data",elements] imports the specified elements.

ImportString["data"] attempts to determine the format of the string from its contents.

ImprovementImportance

ImprovementImportance[rdist,t] gives the improvement importances for all components in the ReliabilityDistribution rdist at time t.

ImprovementImportance[fdist,t] gives the improvement importances for all components in the FailureDistribution fdist at time t.

In

In[n] is a global object that is assigned to have a delayed value of the nth input line. 

Inactivate

Inactivate[expr] replaces all instances of f with Inactive[f] for symbols f used as heads in expr.

Inactivate[expr,patt] inactivates all symbols in expr that match the pattern patt.

Inactive

Inactive[f] is an inactive form of f.

IncidenceGraph

IncidenceGraph[m] gives the graph with incidence matrix m.

IncidenceGraph[{v1,v2,…},m] gives the graph with vertices vi and incidence matrix m.

IncidenceList

IncidenceList[g,v] gives a list of edges incident to vertex v.

IncidenceList[g,patt] gives a list of edges incident to vertices that match the pattern patt.

IncidenceList[g,patt,d] gives a list of incident edges d steps away.

IncidenceList[{v->w,…},…] uses rules v->w to specify the graph g. 

IncidenceMatrix

IncidenceMatrix[g] gives the vertex-edge incidence matrix of the graph g.

IncidenceMatrix[{v->w,…}] uses rules v->w to specify the graph g. 

IncludeAromaticBonds

IncludeAromaticBonds is an option for Molecule that specifies whether aromatic bonds should be detected and labeled.

IncludeConstantBasis

IncludeConstantBasis is an option for LinearModelFit and other fitting functions that specifies whether a constant term should be included if not explicitly given in the list of basis functions.

IncludedContexts

IncludedContexts is an option for FullDefinition, Manipulate and related symbols that gives contexts whose symbols will have their definitions recursively saved.

IncludeDirectories

IncludeDirectories is an option that specifies whether directories are included in evaluations.

IncludeGeneratorTasks

IncludeGeneratorTasks is an option controlling the scope of scheduled task listings.

IncludeHydrogens

IncludeHydrogens is an option that specifies whether hydrogen atoms should be explicitly included in the results.

IncludeInflections

IncludeInflections is an option for linguistic functions that specifies whether inflected forms of words should be included in results.

IncludeMetaInformation

IncludeMetaInformation is an option for Import, Thumbnail, and other functions to specify what types of metadata to include.

IncludePods

IncludePods is an option for WolframAlpha that determines specific pod IDs to include in the results.

IncludeQuantities

IncludeQuantities is an option for DimensionalCombinations for additional quantities to include in the result.

IncludeRelatedTables

IncludeRelatedTables is an option for RelationalDatabase that specifies whether to include tables specified in foreign keys.

IncludeWindowTimes

IncludeWindowTimes is an option to TimeSeriesWindow that specifies whether the endpoints in the time window should be included.

Increment

x++ increases the value of x by 1, returning the old value of x. 

IndefiniteMatrixQ

IndefiniteMatrixQ[m] gives True if m is explicitly indefinite, and False otherwise. 

IndependenceTest

IndependenceTest[v1,v2] tests whether the vectors v1 and v2 are independent.

IndependenceTest[m1,m2] tests whether the matrices m1 and m2 are independent.

IndependenceTest[…,"property"] returns the value of "property".

IndependentEdgeSetQ

IndependentEdgeSetQ[g,elist] yields True if the edge list elist is an independent edge set of the graph g, and False otherwise.

IndependentPhysicalQuantity

IndependentPhysicalQuantity[string] represents a physical quantity string with no relationship to other physical quantities used in QuantityVariable.

IndependentUnit

IndependentUnit[string] represents a unit string with no relationship to other units within a Quantity.

IndependentUnitDimension

IndependentUnitDimension[dim] represents the base dimension dim associated with an independent physical quantity or unit.

IndependentVertexSetQ

IndependentVertexSetQ[g,vlist] yields True if the vertex list vlist is an independent vertex set in the graph g, and False otherwise.

Indeterminate

Indeterminate is a symbol that represents a numerical quantity whose magnitude cannot be determined. 

IndeterminateThreshold

IndeterminateThreshold is an option for Classify, Predict, and related functions that specifies below what probability or probability density a result should be considered indeterminate.

Indexed

Indexed[expr,i] represents the component of expr with index i and formats as expri.

Indexed[expr,{i,j,…}] represents the component with indices i, j, … and formats as expri,j,….

IndexEdgeTaggedGraph

IndexEdgeTaggedGraph[g] sets tags of edges in the graph g to their edge indices.

IndexEdgeTaggedGraph[g,r] sets tags of edges to r,r+1,… 

IndexGraph

IndexGraph[g] replaces the vertices of the graph g by its vertex indices.

IndexGraph[g,r] replaces the vertices with integers r,  r+1, ….

IndexGraph[{v->w,…},…] uses rules v->w to specify the graph g. 

Inequality

Inequality represents a sequence of relational statements.

InexactNumberQ

InexactNumberQ[expr] returns True if expr is an inexact real or complex number, and returns False otherwise.

InfiniteFuture

InfiniteFuture returns a DateObject expression representing infinite future in time.

InfiniteLine

InfiniteLine[{p1,p2}] represents the infinite straight line passing through the points p1 and p2. 

InfiniteLine[p,v] represents the infinite straight line passing through the point p in the direction v. 

InfinitePast

InfinitePast returns a DateObject expression representing infinite past in time.

InfinitePlane

InfinitePlane[{p1,p2,p3}] represents the plane passing through the points p1, p2, and p3.

InfinitePlane[p,{v1,v2}] represents the plane passing through the point p in the directions v1 and v2. 

Infinity

Infinity or ∞ is a symbol that represents a positive infinite quantity. 

Infix

Infix[f[e1,e2,…]] prints with f[e1,e2,…] given in default infix form: e1~f~e2~f~e3…. 

Infix[expr,h] prints with arguments separated by h: e1 h e2 h e3…. 

InflationAdjust

InflationAdjust[quantity,targetdate] attempts to adjust the specified quantity purchasing power to targetdate.

InflationAdjust[quantity] uses the current year as targetdate.

InflationAdjust[quantity,targetunit] converts the currency to targetunit after adjusting to the current year.

InflationAdjust[timeseries,targetdate] attempts to adjust the specified timeseries data purchasing power to targetdate.

InflationMethod

InflationMethod is an option for InflationAdjust that specifies what time series data is to be used for adjustment in time.

Information

Information[expr] gives information about the expression expr. 

Information[expr,prop] gives the value of the property prop for expr.

Information[{expr1,expr2,…},…] gives information about all of the expri.

InformationData

InformationData[assoc] is generated by Information[expr] and handle typesetting and element extraction.

Inherited

Inherited represents an option value to be inherited from an enclosing style, cell, or notebook. 

InhomogeneousPoissonProcess

InhomogeneousPoissonProcess[λ[t],t] represents an inhomogeneous Poisson process with intensity λ[t] given as a function of t.

Initialize

Initialize[sym] initializes the symbol sym from persistent values on the default persistence path.

Initialize[sym,{loc1,…}] initializes the symbol sym from persistent values on the persistence path {loc1,…}.

Initialize["patt"] initializes all variables matching the string pattern "patt".

InitialSeeding

InitialSeeding is an option for NDSolve and other functions that specifies equations that specify initial seeding values for variables that may be used by iterative algorithms.

Inner

Inner[f,list1,list2,g] is a generalization of Dot in which f plays the role of multiplication and g of addition. 

InnerPolygon

InnerPolygon[poly] gives the inner polygon of the polygon poly.

InnerPolyhedron

InnerPolyhedron[poly] gives the inner polyhedron of the polyhedron poly.

Inpaint

Inpaint[image,region] retouches parts of image that correspond to nonzero elements in region.

Input

Input[] interactively reads in one Wolfram Language expression. 

Input[prompt] requests input, displaying prompt as a "prompt".

Input[prompt,init] in a notebook front end uses init as the initial contents of the input field.

InputAssumptions

InputAssumptions is an option for WolframAlpha that specifies assumptions for current query input.

InputForm

InputForm[expr] prints as a version of expr suitable for input to the Wolfram Language. 

InputNamePacket

InputNamePacket[string] is a WSTP packet that contains in string the name to be assigned to the next input.

InputPacket

InputPacket[] is a WSTP packet that indicates a prompt for input as generated by Input.

InputPorts

InputPorts is an option to specify the number, names or shapes of input ports for some neural net layers.

InputStream

InputStream["name",n] is an object that represents an input stream for functions such as Read and Find. 

InputString

InputString[] interactively reads in a character string. 

InputString[prompt] requests input, displaying prompt as a "prompt". 

InputString[prompt,init] in a notebook front end uses init as the initial contents of the input field.

InputStringPacket

InputStringPacket[] is a WSTP packet that requests input in string form.

Insert

Insert[list,elem,n] inserts elem at position n in list. If n is negative, the position is counted from the end. 

Insert[expr,elem,{i,j,…}] inserts elem at position {i,j,…} in expr. 

Insert[expr,elem,{{i1,j1,…},{i2,j2,…},…}] inserts elem at several positions. 

Insert[elem,pos] represents an operator form of Insert that can be applied to an expression.

InsertionFunction

InsertionFunction is an option for template functions that specifies how expressions are to be processed before they are inserted when the template is applied.

InsertLinebreaks

InsertLinebreaks["string"] inserts newline characters into string to make a string in which no line is longer than 78 characters.

InsertLinebreaks["string",n] inserts newline characters to make no line longer than n characters. 

Inset

Inset[obj] represents an object obj inset in a graphic. 

Inset[obj,pos] specifies that the inset should be placed at position pos in the graphic. 

Inset[obj,pos,opos] aligns the inset so that position opos in the object (anchor point)

Install

Install["name"] starts a WSTP-compatible external program and installs Wolfram Language definitions to call functions in it. 

InstallService

InstallService["url"] installs the web service operations in the WSDL description at the URL given.

InstallService["url", "context`"] installs web service operations, creating functions in the specified context.

InstanceNormalizationLayer

InstanceNormalizationLayer[] is equivalent to NormalizationLayer[].

InString

InString[n] is a global object that is assigned to be the text of the nth input line. 

Integer

Integer is the head used for integers. 

IntegerDigits

IntegerDigits[n] gives a list of the decimal digits in the integer n. 

IntegerDigits[n,b] gives a list of the base b digits in the integer n. 

IntegerDigits[n,b,len] pads the list on the left with zeros to give a list of length len. 

IntegerDigits[n,MixedRadix[blist]] uses the mixed radix with list of bases blist.

IntegerExponent

IntegerExponent[n,b] gives the highest power of b that divides n. 

IntegerLength

IntegerLength[n] gives the number of digits in the base 10 representation of the integer n.

IntegerLength[n,b] gives the number of digits in the base b representation of n.

IntegerName

IntegerName[n] gives a string containing the full English name of the integer n.

IntegerName[n,qualifier] gives a string conforming to the given qualifications.

IntegerPart

IntegerPart[x] gives the integer part of x. 

IntegerPartitions

IntegerPartitions[n] gives a list of all possible ways to partition the integer n into smaller integers. 

IntegerPartitions[n,k] gives partitions into at most k integers. 

IntegerPartitions[n,{k}] gives partitions into exactly k integers. 

IntegerPartitions[n,{kmin,kmax}] gives partitions into between kmin and kmax integers. 

IntegerPartitions[n,kspec,{s1,s2,…}] gives partitions involving only the si. 

IntegerPartitions[n,kspec,sspec,m] limits the result to the first m partitions. 

IntegerQ

IntegerQ[expr] gives True if expr is an integer, and False otherwise. 

IntegerReverse

IntegerReverse[n] gives the integer whose digits are reversed with respect to those of the integer n.

IntegerReverse[n,b] gives the integer whose digits in base b are reversed with respect to those of n.

IntegerReverse[n,b,len] gives the integer with reversed digits after padding n with zeros on the left to have len digits.

Integers

Integers represents the domain of integers, as in x∈Integers. 

IntegerString

IntegerString[n] gives a string consisting of the decimal digits in the integer n. 

IntegerString[n,b] gives a string consisting of the base-b digits in the integer n. 

IntegerString[n,b,len] pads the string on the left with zero digits to give a string of length len. 

IntegerString[n,MixedRadix[blist]] uses the mixed radix with a list of bases blist.

IntegerString[n,"numsys"] gives the numeral form of n based on the numeric system defined by "numsys".

Interactive

Interactive is an option that specifies whether a function should create a user prompt when mimicking an action that would have created a user prompt if invoked manually.

InteractiveTradingChart

InteractiveTradingChart[{{date1,{open1,high1,low1,close1,volume1}},…}] makes a chart showing prices and volume for each date. 

InteractiveTradingChart[{"name",daterange}] makes a financial chart for the financial entity "name" over the daterange. 

InteractiveTradingChart[{…},{ind1,ind2,…}] makes a financial chart with indicators ind1, ind2, … . 

InterfaceSwitched

InterfaceSwitched[<|size1->expr1,size2->expr2,…|>] is a construct that behaves as if it were expri when it is in an interface environment with width sizei.

InterfaceSwitched["param",<|key1->expr1,key2->expr2,…|>] behaves as if it were expri when the value of the interface parameter param corresponds to keyi.

Interleaving

Interleaving is an option for Image and related functions that specifies whether data corresponding to different channels in an object such as an image should be interleaved.

InternallyBalancedDecomposition

InternallyBalancedDecomposition[ssm] yields the internally balanced decomposition of the state-space model ssm.

InterpolatingFunction

InterpolatingFunction[domain,table] represents an approximate function whose values are found by interpolation. 

InterpolatingPolynomial

InterpolatingPolynomial[{f1,f2,…},x] constructs an interpolating polynomial in x which reproduces the function values fi at successive integer values 1, 2, … of x. 

InterpolatingPolynomial[{{x1,f1},{x2,f2},…},x] constructs an interpolating polynomial for the function values fi corresponding to x values xi.

InterpolatingPolynomial[{{{x1,y1,…},f1},{{x2,y2,…},f2},…},{x,y,…}] constructs a multidimensional interpolating polynomial in the variables x, y, ….

InterpolatingPolynomial[{{{x1,…},f1,df1,…},…},{x,…}] constructs an interpolating polynomial that reproduces derivatives as well as function values.

Interpolation

Interpolation[{f1,f2,…}] constructs an interpolation of the function values fi, assumed to correspond to x values 1, 2, … . 

Interpolation[{{x1,f1},{x2,f2},…}] constructs an interpolation of the function values fi corresponding to x values xi.

Interpolation[{{{x1,y1,…},f1},{{x2,y2,…},f2},…}] constructs an interpolation of multidimensional data.

Interpolation[{{{x1,…},f1,df1,…},…}] constructs an interpolation that reproduces derivatives as well as function values.

Interpolation[data,x] find an interpolation of data at the point x.

InterpolationOrder

InterpolationOrder is an option for Interpolation, as well as ListLinePlot, ListPlot3D, ListContourPlot, and related functions, that specifies what order of interpolation to use.

InterpolationPoints

InterpolationPoints is an option to SmoothKernelDistribution and FunctionInterpolation that specifies the initial number of interpolation points to use. 

Interpretation

Interpretation[e,expr] represents an object that displays as e, but is interpreted as the unevaluated form of expr if supplied as input. 

Interpretation[{x=x0,y=y0,…},e,expr] allows local variables x, y, … in e and expr.

Interpreter

Interpreter[form] represents an interpreter object that can be applied to an input to try to interpret it as an object of the specified form. 

Interpreter[form,test] returns the interpreted object only if applying test to it yields True; otherwise it returns a Failure object.

Interpreter[form,test,fail] returns the result of applying the function fail if the test fails.

InterpretTemplate

InterpretTemplate is an experimental function used for interpreting Mathematica input.

InterquartileRange

InterquartileRange[data] gives the difference between the upper and lower quartiles q&^3/4-q&^1/4 for the elements in data.

InterquartileRange[data,{{a,b},{c,d}}] uses the quantile definition specified by parameters a, b, c, d.

InterquartileRange[dist] gives the difference between the upper and lower quartiles q3/4-q1/4 for the distribution dist.

Interrupt

Interrupt[] generates an interrupt. 

IntersectedEntityClass

IntersectedEntityClass[class1,class2,…] represents an entity class containing all the entities common to all classi.

IntersectingQ

IntersectingQ[list1,list2] yields True if list1 and list2 have at least one element in common, and False otherwise.

Intersection

Intersection[list1,list2,…] gives a sorted list of the elements common to all the listi. 

Interval

Interval[{min,max}] represents the range of values between min and max. 

Interval[{min1,max1},{min2,max2},…] represents the union of the ranges min1 to max1, min2 to max2, …. 

IntervalIntersection

IntervalIntersection[interval1,interval2,…] gives the interval representing all points common to each of the intervali. 

IntervalMarkers

IntervalMarkers is an option for plotting functions such as ListPlot and BarChart that specifies how to represent uncertainty intervals.

IntervalMarkersStyle

IntervalMarkersStyle is an option for plotting functions that specifies styles in which uncertainty intervals are drawn.

IntervalMemberQ

IntervalMemberQ[interval,x] gives True if the number x lies within the specified interval, and False otherwise. 

IntervalMemberQ[interval1,interval2] gives True if interval2 is completely contained within interval1. 

IntervalMemberQ[interval] represents an operator form of IntervalMemberQ that can be applied to a number.

IntervalUnion

IntervalUnion[interval1,interval2,…] gives an interval containing the set of all points in any of the intervali. 

Inverse

Inverse[m] gives the inverse of a square matrix m. 

InverseBetaRegularized

InverseBetaRegularized[s,a,b] gives the inverse of the regularized incomplete beta function. 

InverseBilateralLaplaceTransform

InverseBilateralLaplaceTransform[expr,s,t] gives the inverse bilateral Laplace transform of expr. 

InverseBilateralLaplaceTransform[expr,{s1,s2,…,sn},{t1,t2,…,tn}] gives the multidimensional inverse bilateral Laplace transform of expr. 

InverseBilateralZTransform

InverseBilateralZTransform[expr,z,n] gives the inverse bilateral Z transform of expr.

InverseBilateralZTransform[expr,{z1,…,zk},{n1,…,nk}] gives the multidimensional inverse bilateral Z transform of expr.

InverseCDF

InverseCDF[dist,q] gives the inverse of the cumulative distribution function for the distribution dist as a function of the variable q.

InverseChiSquareDistribution

InverseChiSquareDistribution[ν] represents an inverse χ2 distribution with ν degrees of freedom.

InverseChiSquareDistribution[ν,ξ] represents a scaled inverse χ2 distribution with ν degrees of freedom and scale ξ.

InverseContinuousWaveletTransform

InverseContinuousWaveletTransform[cwd] gives the inverse continuous wavelet transform of a ContinuousWaveletData object cwd. 

InverseContinuousWaveletTransform[cwd,wave] gives the inverse transform using the wavelet wave.

InverseContinuousWaveletTransform[cwd,wave,octvoc] gives the inverse transform from the wavelet coefficients specified by octvoc.

InverseDistanceTransform

InverseDistanceTransform[image] gives the inverse distance transform of image, returning the result as a binary image.

InverseEllipticNomeQ

InverseEllipticNomeQ[q] gives the parameter m corresponding to the nome q in an elliptic function. 

InverseErf

InverseErf[s] gives the inverse error function obtained as the solution for z in s=erf(z). 

InverseErfc

InverseErfc[s] gives the inverse complementary error function obtained as the solution for z in s=erfc(z). 

InverseFourier

InverseFourier[list] finds the discrete inverse Fourier transform of a list of complex numbers.

InverseFourier[list,{p1,p2,…}] returns the specified positions of the discrete inverse Fourier transform. 

InverseFourierCosTransform

InverseFourierCosTransform[expr,ω,t] gives the symbolic inverse Fourier cosine transform of expr. 

InverseFourierCosTransform[expr,{ω1,ω2,…},{t1,t2,…}] gives the multidimensional inverse Fourier cosine transform of expr. 

InverseFourierSequenceTransform

InverseFourierSequenceTransform[expr,ω,n] gives the inverse discrete-time Fourier transform of expr.

InverseFourierSequenceTransform[expr,{ω1,ω2,…},{n1,n2,…}] gives the multidimensional inverse Fourier sequence transform.

InverseFourierSinTransform

InverseFourierSinTransform[expr,ω,t] gives the symbolic inverse Fourier sine transform of expr. 

InverseFourierSinTransform[expr,{ω1,ω2,…},{t1,t2,…}] gives the multidimensional inverse Fourier sine transform of expr. 

InverseFourierTransform

InverseFourierTransform[expr,ω,t] gives the symbolic inverse Fourier transform of expr. 

InverseFourierTransform[expr,{ω1,ω2,…},{t1,t2,…}] gives the multidimensional inverse Fourier transform of expr. 

InverseFunctions

InverseFunctions is an option for Solve and related functions that specifies whether inverse functions should be used. 

InverseGammaDistribution

InverseGammaDistribution[α,β] represents an inverse gamma distribution with shape parameter α and scale parameter β.

InverseGammaDistribution[α,β,γ,μ] represents a generalized inverse gamma distribution with shape parameters α and γ, scale parameter β, and location parameter μ.

InverseGammaRegularized

InverseGammaRegularized[a,s] gives the inverse of the regularized incomplete gamma function. 

InverseGaussianDistribution

InverseGaussianDistribution[μ,λ] represents an inverse Gaussian distribution with mean μ and scale parameter λ.

InverseGaussianDistribution[μ,λ,θ] represents a generalized inverse Gaussian distribution with parameters μ, λ, and θ.

InverseGudermannian

InverseGudermannian[z] gives the inverse Gudermannian function gd-1(z).

InverseHankelTransform

InverseHankelTransform[expr,s,r] gives the inverse Hankel transform of order 0 for expr.

InverseHankelTransform[expr,s,r,ν] gives the inverse Hankel transform of order ν for expr.

InverseHaversine

InverseHaversine[z] gives the inverse haversine function hav-1(z).

InverseImagePyramid

InverseImagePyramid[pyr] reconstructs an image from an ImagePyramid object pyr.

InverseImagePyramid[pyr,pyrtype] assumes the specified pyramid type pyrtype.

InverseImagePyramid[pyr,pyrtype,n] reconstructs up to pyramid level n.

InverseImagePyramid[pyr,pyrtype,{size}] reconstructs up to the smallest pyramid level larger than the specified size.

InverseJacobiCD

InverseJacobiCD[v,m] gives the inverse Jacobi elliptic function cd-1(vm).

InverseJacobiCN

InverseJacobiCN[v,m] gives the inverse Jacobi elliptic function cn-1(vm).

InverseJacobiCS

InverseJacobiCS[v,m] gives the inverse Jacobi elliptic function cs-1(vm).

InverseJacobiDC

InverseJacobiDC[v,m] gives the inverse Jacobi elliptic function dc-1(vm).

InverseJacobiDN

InverseJacobiDN[v,m] gives the inverse Jacobi elliptic function dn-1(vm).

InverseJacobiDS

InverseJacobiDS[v,m] gives the inverse Jacobi elliptic function ds-1(vm).

InverseJacobiNC

InverseJacobiNC[v,m] gives the inverse Jacobi elliptic function nc-1(vm).

InverseJacobiND

InverseJacobiND[v,m] gives the inverse Jacobi elliptic function nd-1(vm).

InverseJacobiNS

InverseJacobiNS[v,m] gives the inverse Jacobi elliptic function ns-1(vm).

InverseJacobiSC

InverseJacobiSC[v,m] gives the inverse Jacobi elliptic function sc-1(vm).

InverseJacobiSD

InverseJacobiSD[v,m] gives the inverse Jacobi elliptic function sd-1(vm).

InverseJacobiSN

InverseJacobiSN[v,m] gives the inverse Jacobi elliptic function sn-1(vm).

InverseMellinTransform

InverseMellinTransform[expr,s,x] gives the inverse Mellin transform of expr. 

InversePermutation

InversePermutation[perm] returns the inverse of permutation perm.

InverseRadon

InverseRadon[image] gives the inverse discrete Radon transform of image.

InverseRadon[image,{w,h}] specifies the width w and the height h of the resulting image.

InverseRadonTransform

InverseRadonTransform[expr,{p,ϕ},{x,y}] gives the inverse Radon transform of expr.

InverseSeries

InverseSeries[s] takes the series s, and gives a series for the inverse of the function represented by s. 

InverseSeries[s,x] uses the variable x in the inverse series.

InverseShortTimeFourier

InverseShortTimeFourier[input] reconstructs the signal from short-time Fourier data.

InverseShortTimeFourier[input,n] assumes the spectrogram data was computed with partitions of length n.

InverseShortTimeFourier[input,n,d] assumes partitions with offset d.

InverseShortTimeFourier[input,n,d,wfun] assumes a smoothing window wfun was applied to each partition.

InverseSpectrogram

InverseSpectrogram[data] reconstructs the signal from the magnitude spectrogram data.

InverseSpectrogram[img] reconstructs the signal, assuming that the image img is the magnitude spectrogram.

InverseSpectrogram[input,n] assumes the spectrogram data was computed with partitions of length n.

InverseSpectrogram[input,n,d] assumes partitions with offset d.

InverseSpectrogram[input,n,d,wfun] assumes a smoothing window wfun was applied to each partition.

InverseSurvivalFunction

InverseSurvivalFunction[dist,q] gives the inverse of the survival function for the distribution dist as a function of the variable q.

InverseTransformedRegion

InverseTransformedRegion[reg,f,n] represents the inverse transformed region {p∈n|f(p)∈reg}, where reg is a region and f is a function. 

InverseWaveletTransform

InverseWaveletTransform[dwd] gives the inverse wavelet transform of a DiscreteWaveletData object dwd.

InverseWaveletTransform[dwd,wave] gives the inverse transform using the wavelet wave.

InverseWaveletTransform[dwd,wave,wind] gives the inverse transform from the wavelet coefficients specified by wind.

InverseWeierstrassP

InverseWeierstrassP[p,{g2,g3}] gives a value of u for which the Weierstrass function ℘(u;g2,g3) is equal to p. 

InverseWishartMatrixDistribution

InverseWishartMatrixDistribution[ν,Σ] represents an inverse Wishart matrix distribution with ν degrees of freedom and covariance matrix Σ.

InverseZTransform

InverseZTransform[expr,z,n] gives the inverse Z transform of expr. 

InverseZTransform[expr,{z1,…,zm},{n1,…,nm}] gives the multiple inverse Z transform of expr.

Invisible

Invisible[expr] displays as space that is the same size as the formatted version of expr.

IPAddress

IPAddress["address"] is a symbolic representation of an IPv4 or IPv6 IP address.

IrreduciblePolynomialQ

IrreduciblePolynomialQ[poly] tests whether poly is an irreducible polynomial over the rationals.

IrreduciblePolynomialQ[poly,Modulus->p] tests whether poly is irreducible modulo a prime p.

IrreduciblePolynomialQ[poly,Extension->{a1,a2,…}] tests whether poly is irreducible over the field extension generated by the algebraic numbers ai.

IrreduciblePolynomialQ[poly,Extension->All] tests whether poly is absolutely irreducible over the complex numbers.

IslandData

IslandData[entity,property] gives the value of the specified property for the island entity.

IslandData[{entity1,entity2,…},property] gives a list of property values for the specified island entities.

IslandData[entity,property,annotation] gives the specified annotation associated with the given property.

IsolatingInterval

IsolatingInterval[a] gives a rational isolating interval for the algebraic number a.

IsolatingInterval[a,dx] gives an isolating interval of width at most dx.

IsomorphicGraphQ

IsomorphicGraphQ[g1,g2] yields True if the graphs g1 and g2 are isomorphic, and False otherwise.

IsomorphicSubgraphQ

IsomorphicSubgraphQ[g1,g2] yields True if the graph g1 is isomorphic to a subgraph of the graph g2.

IsotopeData

IsotopeData[{Z,A},"property"] gives the value of the specified property for the isotope with atomic number Z and mass number A.

IsotopeData["name","property"] gives the value of the property for the named isotope.

Italic

Italic represents an italic font slant.

ItoProcess

ItoProcess[{a,b},x,t] represents an Ito process x(t), where x(t)a(t,x(t))t+b(t,x(t)).w(t).

ItoProcess[{a,b,c},x,t] represents an Ito process y(t)c(t,x(t)), where x(t)a(t,x(t))t+b(t,x(t)).w(t) .

ItoProcess[…,{x,x0},{t,t0}] uses initial condition x(t0)x0.

ItoProcess[…,…,…,Σ] uses a Wiener process w(t), with covariance Σ.

ItoProcess[proc] converts proc to a standard Ito process whenever possible. 

ItoProcess[sdeqns,expr,x,t,wdproc] represents an Ito process specified by a stochastic differential equation sdeqns, output expression expr, with state x and time t, driven by w following the process dproc. 

JaccardDissimilarity

JaccardDissimilarity[u,v] gives the Jaccard dissimilarity between Boolean vectors u and v.

JacobiAmplitude

JacobiAmplitude[u,m] gives the amplitude am(um) for Jacobi elliptic functions. 

Jacobian

Jacobian is an option for FindRoot. Jacobian -> Automatic attempts symbolic computation of the Jacobian of the system of functions whose root is being sought. A typical setting is Jacobian -> {{2 x, Sign[y]}, {y, x}}.

JacobiCD

JacobiCD[u,m] gives the Jacobi elliptic function cd(u|m).

JacobiCN

JacobiCN[u,m] gives the Jacobi elliptic function cn(u|m).

JacobiCS

JacobiCS[u,m] gives the Jacobi elliptic function cs(u|m).

JacobiDC

JacobiDC[u,m] gives the Jacobi elliptic function dc(u|m).

JacobiDN

JacobiDN[u,m] gives the Jacobi elliptic function dn(u|m).

JacobiDS

JacobiDS[u,m] gives the Jacobi elliptic function ds(u|m).

JacobiEpsilon

JacobiEpsilon[u,m] gives the Jacobi epsilon function ℰ(um).

JacobiNC

JacobiNC[u,m] gives the Jacobi elliptic function nc(u|m).

JacobiND

JacobiND[u,m] gives the Jacobi elliptic function nd(u|m).

JacobiNS

JacobiNS[u,m] gives the Jacobi elliptic function ns(u|m).

JacobiP

JacobiP[n,a,b,x] gives the Jacobi polynomial Pn(a,b)(x). 

JacobiSC

JacobiSC[u,m] gives the Jacobi elliptic function sc(u|m).

JacobiSD

JacobiSD[u,m] gives the Jacobi elliptic function sd(u|m).

JacobiSN

JacobiSN[u,m] gives the Jacobi elliptic function sn(um).

JacobiSymbol

JacobiSymbol[n,m] gives the Jacobi symbol (n/m). 

JacobiZeta

JacobiZeta[ϕ,m] gives the Jacobi zeta function Ζ(ϕm). 

JacobiZN

JacobiZN[u,m] gives the Jacobi zeta function zn(um).

JankoGroupJ1

JankoGroupJ1[] represents the sporadic simple Janko group J1.

JankoGroupJ2

JankoGroupJ2[] represents the sporadic simple Janko group J2.

JankoGroupJ3

JankoGroupJ3[] represents the sporadic simple Janko group J3.

JankoGroupJ4

JankoGroupJ4[] represents the sporadic simple Janko group J4.

JarqueBeraALMTest

JarqueBeraALMTest[data] tests whether data is normally distributed using the Jarque–Bera ALM test.

JarqueBeraALMTest[data,"property"] returns the value of "property".

JohnsonDistribution

JohnsonDistribution["SB",γ,δ,μ,σ] represents a bounded Johnson distribution with shape parameters γ, δ, location parameter μ, and scale parameter σ.

JohnsonDistribution["SL",γ,δ,μ,σ] represents a semi-bounded Johnson distribution.

JohnsonDistribution["SU",γ,δ,μ,σ] represents an unbounded Johnson distribution.

JohnsonDistribution["SN",γ,δ,μ,σ] represents a normal Johnson distribution.

Join

Join[list1,list2,…] concatenates lists or other expressions that share the same head.

Join[list1,list2,…,n] joins the objects at level n in each of the listi.

JoinAcross

JoinAcross[{a1,a2,…},{b1,b2,…},key] gives a list of associations obtained by joining those pairs of associations ai and bj in which the values associated with key are the same. 

JoinAcross[{a1,a2,…},{b1,b2,…},{key1,key2,…}] joins pairs of associations only when the values associated with all keys keyi are the same.

JoinAcross[{a1,a2,…},{b1,b2,…},keya->keyb] joins pairs of associations ai, bj in which the values associated with keya in the ai are the same as those associated with keyb in the bj.

JoinAcross[{a1,a2,…},{b1,b2,…},{keya1->keyb1,…}] joins pairs of associations in which pairs of corresponding values agree.

JoinAcross[alist,blist,keyspec,"joinspec"] uses joinspec to determine when to allow associations that contain missing elements to be generated.

Joined

Joined is an option for ListPlot and related functions that specifies whether points in each dataset should be joined into a line, or should be plotted as separate points. 

JoinedCurve

JoinedCurve[{segment1,segment2,…}] represents a curve consisting of segment1 followed by segment2 etc. 

JoinedCurve[{component1,component2,…}] represents a list of separate component curves component1, component2, etc. 

JoinForm

JoinForm[type] is a graphics directive that specifies what type of joins should be used to connect segments of lines, tubes, edges, and related primitives.

JordanDecomposition

JordanDecomposition[m] yields the Jordan decomposition of a square matrix m. The result is a list {s,j} where s is a similarity matrix and j is the Jordan canonical form of m.

JordanModelDecomposition

JordanModelDecomposition[ssm] yields the Jordan decomposition of the state-space model ssm. 

JulianDate

JulianDate[] gives the current number of days since noon on November 24, 4714 BCE in the GMT time zone. 

JulianDate[date] gives the number of days for the specified date.

JulianDate["type"] gives the Julian date variant of the specified type.

JulianDate["type",date] gives the variant for the specified date.

JuliaSetBoettcher

JuliaSetBoettcher[c,z] gives the Böttcher coordinate of z with respect to the quadratic Julia set Jc.

K

K is a default generic name for a summation index in a symbolic sum.

KagiChart

KagiChart[{{date1,p1},{date2,p2},…}] makes a Kagi chart with prices pi at date datei.

KagiChart[{"name",daterange}] makes a Kagi chart of closing prices for the financial entity "name" over the date range daterange.

KagiChart[{…},rt] makes a Kagi chart with reversal threshold rt.

KaiserBesselWindow

KaiserBesselWindow[x] represents a Kaiser–Bessel window function of x.

KaiserWindow

KaiserWindow[x] represents a Kaiser window function of x.

KaiserWindow[x,α] uses the parameter α.

KalmanEstimator

KalmanEstimator[ssm,{w,v}] constructs the Kalman estimator for the StateSpaceModel ssm with process and measurement noise covariance matrices w and v. 

KalmanEstimator[ssm,{w,v,h}] includes the cross-covariance matrix h.

KalmanEstimator[{ssm,sensors},{…}] specifies sensors as the noisy measurements of ssm.

KalmanEstimator[{ssm,sensors,dinputs},{…}] specifies dinputs as the deterministic inputs of ssm.

KalmanFilter

KalmanFilter[tproc,data] filters data using the time series model given by tproc.

KarhunenLoeveDecomposition

KarhunenLoeveDecomposition[{a1,a2,…}] gives the Karhunen–Loeve transform {{b1,b2,…},m} of the numerical arrays {a1,a2,…}, where m.aibi. 

KarhunenLoeveDecomposition[{b1,b2,…},m] uses the inverse of the matrix m for transforming bi to ai.

KaryTree

KaryTree[n] gives a binary tree with n vertices.

KaryTree[n,k] gives a k-ary tree with n vertices.

KatzCentrality

KatzCentrality[g,α] gives a list of Katz centralities for the vertices in the graph g and weight α.

KatzCentrality[g,α,β] gives a list of Katz centralities using weight α and initial centralities β.

KatzCentrality[{v->w,…},…] uses rules v->w to specify the graph g. 

KCoreComponents

KCoreComponents[g,k] gives the k-core components of the underlying simple graph of g.

KCoreComponents[g,k,"In"] gives the k-core components with vertex in-degrees at least k.

KCoreComponents[g,k,"Out"] gives the k-core components with vertex out-degrees at least k.

KCoreComponents[{v->w,…},…] uses rules v->w to specify the graph g. 

KDistribution

KDistribution[ν,w] represents a K distribution with shape parameters ν and w.

KEdgeConnectedComponents

KEdgeConnectedComponents[g,k] gives the k-edge-connected components of the graph g.

KEdgeConnectedComponents[g,k,{v1,v2,…}] gives the k-edge-connected components that include at least one of the vertices v1, v2, ….

KEdgeConnectedComponents[{v->w,…},…] uses rules v->w to specify the graph g. 

KEdgeConnectedGraphQ

KEdgeConnectedGraphQ[g,k] yields True if the graph g is k-edge-connected and False otherwise.

KeepExistingVersion

KeepExistingVersion is an option for PacletInstall and PacletInstallSubmit that specifies whether an older version of a paclet should remain installed when a newer one gets installed. 

KelvinBei

KelvinBei[z] gives the Kelvin function bei(z).

KelvinBei[n,z] gives the Kelvin function bein(z). 

KelvinBer

KelvinBer[z] gives the Kelvin function ber(z).

KelvinBer[n,z] gives the Kelvin function bern(z). 

KelvinKei

KelvinKei[z] gives the Kelvin function kei(z).

KelvinKei[n,z] gives the Kelvin function kein(z). 

KelvinKer

KelvinKer[z] gives the Kelvin function ker(z).

KelvinKer[n,z] gives the Kelvin function kern(z). 

KendallTauTest

KendallTauTest[v1,v2] tests whether the vectors v1 and v2 are independent.

KendallTauTest[m1,m2] tests whether the matrices m1 and m2 are independent.

KendallTauTest[…,"property"] returns the value of "property".

KernelFunction

KernelFunction[f] represents a function to be evaluated in the Wolfram Language kernel, even when called from compiled code.

KernelMixtureDistribution

KernelMixtureDistribution[{x1,x2,…}] represents a kernel mixture distribution based on the data values xi.

KernelMixtureDistribution[{{x1,y1,…},{x2,y2,…},…}] represents a multivariate kernel mixture distribution based on data values {xi,yi,…}.

KernelMixtureDistribution[…,bw] represents a kernel mixture distribution with bandwidth bw.

KernelMixtureDistribution[…,bw,ker] represents a kernel mixture distribution with bandwidth bw and smoothing kernel ker.

KernelObject

KernelObject[…] represents a kernel available for parallel computing.

Kernels

Kernels[] gives the list of running kernels available for parallel computing.

Key

Key[key] represents a key used to access a value in an association or a column in a Tabular object.

Key[key][assoc] extracts the value corresponding to key in the association assoc.

KeyCollisionFunction

KeyCollisionFunction is an option for JoinAcross that specifies how to handle pairs of elements that are not being joined but nevertheless have the same key.

KeyComplement

KeyComplement[{assocall,assoc1,assoc2,…}] generates an association in which only elements whose keys appear in assocall but not in any of the associ are retained.

KeyDrop

KeyDrop[assoc,{key1,key2,…}] yields an association from which elements with keys keyi have been dropped. 

KeyDrop[{assoc1,assoc2,…},keys] gives a list of associations.

KeyDrop[keys] represents an operator form of KeyDrop that can be applied to an expression.

KeyDropFrom

KeyDropFrom[a,key] changes the association a by dropping the element with the specified key.

KeyDropFrom[a,{key1,key2,…}] drops the elements with keys keyi.

KeyExistsQ

KeyExistsQ[assoc,key] returns True if the specified key exists in the association assoc, and False otherwise.

KeyExistsQ[key] represents an operator form of KeyExistsQ that can be applied to an expression.

KeyFreeQ

KeyFreeQ[assoc,form] yields True if no key in the association assoc matches form, and yields False otherwise.

KeyFreeQ[form] represents an operator form of KeyFreeQ that can be applied to an expression.

KeyIntersection

KeyIntersection[{assoc1,assoc2,…}] generates a list of associations in which only elements whose keys appear in all the associ are retained.

KeyMap

KeyMap[f,<|key1->val1,key2->val2,…|>] maps f over the keys in an association, giving <|f[key1]->val1,f[key2]->val2,…|>.

KeyMap[f] represents an operator form of KeyMap that can be applied to an expression.

KeyMemberQ

KeyMemberQ[assoc,form] yields True if a key in the association assoc matches form, and False otherwise.

KeyMemberQ[form] represents an operator form of KeyMemberQ that can be applied to an expression.

KeypointStrength

KeypointStrength is an option for ImageKeypoints and related functions to specify a minimum strength of detected keypoints.

Keys

Keys[<|key1->val1,key2->val2,…|>] gives a list of the keys keyi in an association.

Keys[{key1->val1,key2->val2,…}] gives a list of the keyi in a list of rules.

Keys[expr,h] gives a list of keys in expr, wrapping each of them with head h before evaluation.

KeySelect

KeySelect[assoc,crit] selects elements in the association assoc for which crit applied to their keys is True.

KeySelect[crit] represents an operator form of KeySelect that can be applied to an expression.

KeySort

KeySort[assoc] orders the elements of an association by sorting its keys.

KeySort[assoc,p] orders the elements of an association using the ordering function p.

KeySortBy

KeySortBy[assoc,f] sorts the elements of an association in the order defined by applying f to each of their keys.

KeySortBy[f] represents an operator form of KeySortBy that can be applied to an expression.

KeyTake

KeyTake[assoc,{key1,key2,…}] yields an association containing only the elements with keys keyi.

KeyTake[{assoc1,assoc2,…},keys] gives a list of associations.

KeyTake[{key1,key2,…}] represents an operator form of KeyTake that can be applied to an expression.

KeyUnion

KeyUnion[{assoc1,assoc2,…}] generates a list of associations in which each association has the union of the keys of the associ, padding by inserting values of Missing[…] if necessary.

KeyUnion[{assoc1,assoc2,…},f] uses f[key] as the value associated with a missing key. 

KeyValueMap

KeyValueMap[f,<|key1->val1,key2->val2,…|>] gives the list {f[key1,val1],f[key2,val2],…}.

KeyValueMap[f] represents an operator form of KeyValueMap that can be applied to an expression.

KeyValuePattern

KeyValuePattern[{patt1,…}] is a pattern object that represents an association or list of rules that includes elements matching each of the patti.

Khinchin

Khinchin is Khinchin's constant, with numerical value ≃2.68545. 

KillProcess

KillProcess[proc] kills the external process represented by the ProcessObject proc.

KirchhoffGraph

KirchhoffGraph[kmat] gives the graph with Kirchhoff matrix kmat.

KirchhoffGraph[{v1,v2,…},kmat] gives the graph with vertices vi and Kirchhoff matrix kmat.

KirchhoffMatrix

KirchhoffMatrix[g] gives the Kirchhoff matrix of the graph g.

KirchhoffMatrix[{v->w,…}] uses rules v->w to specify the graph g. 

KleinInvariantJ

KleinInvariantJ[τ] gives the Klein invariant modular elliptic function J(τ). 

KnapsackSolve

KnapsackSolve[{cost1,cost2,…},maxtotalcost] solves the knapsack problem of finding the maximum number of items associated with each of the costi, subject to the constraint that the total cost is not larger than maxtotalcost.

KnapsackSolve[{{payoff1,cost1},{payoff2,cost2},…},maxtotalcost] finds a number of items that maximizes the total payoff, while satisfying the constraint on the total cost.

KnapsackSolve[{{payoff1,cost1,maxcount1},…},maxtotalcost] allows at most maxcounti copies of item i.

KnapsackSolve[items,{maxtotalpayoff,maxtotalcost}] finds a result that gives a total payoff not larger than maxtotalpayoff.

KnapsackSolve[items,{maxtotalpayoff,maxtotalcost,maxtotalcount}] adds the constraint of having no more than maxtotalcount items in total. 

KnapsackSolve[<|label1->itemspec1,…|>,maxtotals] labels each type of item and gives the result as an association.

KnightTourGraph

KnightTourGraph[m,n] gives a Knight's tour graph on an mn chessboard.

KnotData

KnotData[knot,"property"] gives the specified property for a knot.

KnotData[knot] gives an image of the knot.

KnotData["class"] gives a list of knots in the specified class.

KnownUnitQ

KnownUnitQ[expr] returns True if expr is a canonical unit, and False otherwise.

KnownUnitQ[expr,dims] gives True if expr is a canonical unit with physical dimensions dims, and False otherwise.

KochCurve

KochCurve[n] gives the line segments representing the nth-step Koch curve.

KochCurve[n,{θ1,θ2,…}] takes a series of steps of unit length at successive relative angles θi. 

KochCurve[n,{{r1,θ1},{r2,θ2},…}] takes successive steps of lengths proportional to ri.

KolmogorovSmirnovTest

KolmogorovSmirnovTest[data] tests whether data is normally distributed using the Kolmogorov–Smirnov test.

KolmogorovSmirnovTest[data,dist] tests whether data is distributed according to dist using the Kolmogorov–Smirnov test.

KolmogorovSmirnovTest[data,dist,"property"] returns the value of "property".

KroneckerDelta

KroneckerDelta[n1,n2,…] gives the Kronecker delta δn1 n2 …, equal to 1 if all the ni are equal, and 0 otherwise. 

KroneckerModelDecomposition

KroneckerModelDecomposition[ssm] yields the Kronecker decomposition of a descriptor state-space model ssm. 

KroneckerProduct

KroneckerProduct[m1,m2,…] constructs the Kronecker product of the arrays mi.

KroneckerSymbol

KroneckerSymbol[n,m] gives the Kronecker symbol (n/m). 

KuiperTest

KuiperTest[data] tests whether data is normally distributed using the Kuiper test.

KuiperTest[data,dist] tests whether data is distributed according to dist using the Kuiper test.

KuiperTest[data,dist,"property"] returns the value of "property".

KumaraswamyDistribution

KumaraswamyDistribution[α,β] represents a Kumaraswamy distribution with shape parameters α and β.

Kurtosis

Kurtosis[data] gives the coefficient of kurtosis for the elements in data.

Kurtosis[dist] gives the coefficient of kurtosis for the distribution dist.

KuwaharaFilter

KuwaharaFilter[data,r] computes for each element p in data the variance of the values in the four (r+1)×(r+1) squares that have p as a corner, and replaces p with the mean of the values of the square with least variance.

KVertexConnectedComponents

KVertexConnectedComponents[g,k] gives the k-vertex-connected components of the graph g.

KVertexConnectedComponents[g,k,{v1,v2,…}] gives the k-vertex-connected components that include at least one of the vertices v1, v2, … .

KVertexConnectedGraphQ

KVertexConnectedGraphQ[g,k] yields True if the graph g is k-vertex-connected and False otherwise.

LABColor

LABColor[l,a,b] represents a color in the CIELAB color space with lightness l and color components a and b. 

LABColor[l,a,b,α] specifies opacity α. 

LABColor["string"] returns a color from an HTML color name etc.

LABColor[color] returns the CIELAB representation of color.

Label

Label[tag] represents a point in a compound expression to which control can be transferred using Goto. 

Labeled

Labeled[expr,lbl] displays expr labeled with lbl. 

Labeled[expr,lbl,pos] places lbl at a position specified by pos. 

Labeled[expr,{lbl1,lbl2,…},{pos1,…}] places the lbli at positions posi. 

Labeled[expr,{lbl1,lbl2,lbl3,lbl4},All] places the lbli at the bottom, left, top, and right, respectively. 

LabelingFunction

LabelingFunction is an option for data visualization functions to automatically label elements of a visualization.

LabelingSize

LabelingSize is an option to visualization functions that specifies the size to be used for labels and callouts.

LabelVisibility

LabelVisibility is an option for Callout and Labeled in plotting functions that determines which labels are shown.

LakeData

LakeData[entity,property] gives the value of the specified property for the lake entity.

LakeData[{entity1,entity2,…},property] gives a list of property values for the specified lake entities.

LakeData[entity,property,annotation] gives the specified annotation associated with the given property.

LambdaComponents

LambdaComponents[g] gives the lambda components of the graph g.

LambdaComponents[g,{v1,v2,…}] gives the lambda components that include at least one of the vertices {v1,v2,…}.

LambdaComponents[{v->w,…},…] uses rules v->w to specify the graph g. 

LameC

LameC[ν,j,z,m] gives the jth Lamé function Ecν(j)(zm) of order ν with elliptic parameter m.

LameCPrime

LameCPrime[ν,j,z,m] gives the z-derivative of the jth Lamé function Ecν(j)(zm) of order ν with elliptic parameter m.

LameEigenvalueA

LameEigenvalueA[ν,j,m] gives the jth Lamé eigenvalue aν(j)(m) of order ν with elliptic parameter m for the function LameC[ν,j,z,m].

LameEigenvalueB

LameEigenvalueB[ν,j,m] gives the jth Lamé eigenvalue bν(j)(m) of order ν with elliptic parameter m for the Lamé function LameS[ν,j,z,m].

LameS

LameS[ν,j,z,m] gives the jth Lamé function Esν(j)(zm) of order ν with elliptic parameter m.

LameSPrime

LameSPrime[ν,j,z,m] gives the z-derivative of the jth Lamé function Esν(j)(zm) of order ν with elliptic parameter m.

LaminaData

LaminaData[entity,property] gives the value of the specified property for the lamina entity.

LaminaData[{entity1,entity2,…},property] gives a list of property values for the specified lamina entities.

LaminaData[entity,property,annotation] gives the specified annotation associated with the given property.

LanczosWindow

LanczosWindow[x] represents a Lanczos window function of x.

LandauDistribution

LandauDistribution[μ,σ] represents a Landau distribution with location parameter μ and scale parameter σ.

LandauDistribution[] represents a Landau distribution with location parameter 0 and scale parameter 1.

Language

Language is an option that specifies the language to use.

LanguageCategory

LanguageCategory is an option for Cell that determines in what category of language the contents of the cell should be assumed to be for purposes of spell checking and hyphenation. 

LanguageData

LanguageData[entity,property] gives the value of the specified property for the language entity.

LanguageData[{entity1,entity2,…},property] gives a list of property values for the specified language entities.

LanguageData[entity,property,annotation] gives the specified annotation associated with the given property.

LanguageIdentify

LanguageIdentify["string"] attempts to determine what human language text in string is in, predominantly.

LanguageIdentify[audio] performs language identification in audio recording audio.

LanguageIdentify[video] performs language identification of the audio track in video.

LaplaceDistribution

LaplaceDistribution[μ,β] represents a Laplace double-exponential distribution with mean μ and scale parameter β.

LaplaceDistribution[] represents a Laplace double-exponential distribution with mean 0 and scale parameter 1.

Laplacian

Laplacian[f,{x1,…,xn}] gives the Laplacian ∂2f/∂x12+…+∂2f/∂xn2.

Laplacian[f,{x1,…,xn},chart] gives the Laplacian in the given coordinates chart.

LaplacianFilter

LaplacianFilter[data,r] convolves data with a radius-r Laplacian kernel.

LaplacianFilter[data,{r1,r2,…}] uses radius ri at level i in data.

LaplacianGaussianFilter

LaplacianGaussianFilter[data,r] convolves data with a Laplacian of Gaussian kernel of pixel radius r.

LaplacianGaussianFilter[data,{r,σ}]  convolves data with a Laplacian of Gaussian kernel of radius r and standard deviation σ.

LaplacianPDETerm

LaplacianPDETerm[vars] represents a Laplacian term ∇2{x1,…,xn}u with model variables vars.

LaplacianPDETerm[vars,pars] uses model parameters pars.

Large

Large is a style or option setting that specifies that objects should be large.

Larger

Larger is a style or option setting that specifies that objects should be larger.

Last

Last[expr] gives the last element in expr. 

Last[expr,def] gives the last element if there are any elements, or def otherwise.

Latitude

Latitude[pos] gives the latitude in degrees of a geographic position specified by pos.

Latitude[pos,datum] gives the latitude referring to the specified geodetic datum.

LatitudeLongitude

LatitudeLongitude[pos] gives a list of the latitude and longitude in degrees of a geographic position specified by pos.

LatitudeLongitude[pos,datum] gives the latitude and longitude referring to the specified geodetic datum.

LatticeData

LatticeData[lattice,"property"] gives the specified property for a lattice.

LatticeData[n] gives a list of named lattices of dimension n.

LatticeReduce

LatticeReduce[{v1,v2,…}] gives a reduced basis for the set of vectors vi. 

Launch

Launch is a setting for the LinkMode option of LinkOpen.  LinkMode->Launch causes a link to be created by launching another program.

LaunchKernels

LaunchKernels[] launches all currently configured parallel subkernels.

LaunchKernels[n] launches n local subkernels on the current computer.

LaunchKernels[ker] launches the kernel specified by ker.

LaunchKernels[{ker1,ker2,…}] launches the kernels keri.

LayeredGraphPlot

LayeredGraphPlot[g] generates a layered plot of the graph g.

LayeredGraphPlot[{e1,e2,…}] generates a layered plot of the graph with edges ej.

LayeredGraphPlot[{…,w[ei],…}] plots ei with features defined by the symbolic wrapper w.

LayeredGraphPlot[{vi1->vj1,…}] uses rules vik->vjk to specify the graph g.

LayeredGraphPlot[m] uses the adjacency matrix m to specify the graph g.

LayeredGraphPlot[…,v->pos] places the dominant vertex v in the plot at position pos.

LayeredGraphPlot3D

LayeredGraphPlot3D[g] generates a 3D layered plot of the graph g.

LayeredGraphPlot3D[{e1,e2,…}] generates a 3D layered plot of the graph with edges ei.

LayeredGraphPlot3D[{…,w[ei],…}] plots ei with features defined by the symbolic wrapper w.

LayeredGraphPlot3D[{vi1->vj1,…}] uses rules vik->vjk to specify the graph g.

LayeredGraphPlot3D[m] uses the adjacency matrix m to specify the graph g.

LayeredGraphPlot3D[…,v->pos] places the dominant vertex v in the plot at position pos.

LayerSizeFunction

LayerSizeFunction is an option for TreePlot that gives a function to specify the relative height to allow for each layer.

LCHColor

LCHColor[l,c,h] represents a color in the LCH color space with lightness l, chroma c and hue h.

LCHColor[l,c,h,a] specifies opacity a. 

LCHColor["string"] returns a color from an HTML color name etc.

LCHColor[color] returns the LCH representation of color.

LCM

LCM[n1,n2,…] gives the least common multiple of the ni. 

LeaderSize

LeaderSize is an option for Callout that specifies what sizes to use for leader lines.

LeafCount

LeafCount[expr] gives the total number of indivisible subexpressions in expr. 

LeapVariant

LeapVariant[n] represents a repeated calendar element caused by a leap period.

LeapYearQ

LeapYearQ[date] returns True if the year corresponding to date is a leap year.

LearnDistribution

LearnDistribution[{example1,example2,…}] generates a LearnedDistribution[…] that attempts to represent an underlying distribution for the examples given.

LearnedDistribution

LearnedDistribution[…] represents a distribution generated by LearnDistribution.

LearningRate

LearningRate is an option for NetTrain that specifies the rate at which to adjust neural net weights in order to minimize the training loss.

LearningRateMultipliers

LearningRateMultipliers is an option for net layers and for NetTrain, NetChain, NetGraph that specifies learning rate multipliers to apply during training.

LeastSquares

LeastSquares[m,b] finds an x that solves the linear least-squares problem for the matrix equation m.x==b.

LeastSquares[a,b] finds an x that solves the linear least-squares problem for the array equation a.x==b.

LeastSquaresFilterKernel

LeastSquaresFilterKernel[{{ω1,…,ωk-1},{a1,…,ak}},n] creates a k-band finite impulse response (FIR) filter kernel of length n designed using a least squares method, given the specified frequencies ωi and amplitudes ai.

LeastSquaresFilterKernel[{"type",spec},n] uses the full filter specification {"type",spec}.

Left

Left is a symbol that represents the left-hand side for purposes of alignment and positioning. 

LeftArrow

LeftArrow[x,y,…] displays as x←y←….

LeftArrowBar

LeftArrowBar[x,y,…] displays as x⇤y⇤….

LeftArrowRightArrow

LeftArrowRightArrow[x,y,…] displays as x⇆y⇆….

LeftDownTeeVector

LeftDownTeeVector[x,y,…] displays as x⥡y⥡….

LeftDownVector

LeftDownVector[x,y,…] displays as x⇃y⇃….

LeftDownVectorBar

LeftDownVectorBar[x,y,…] displays as x⥙y⥙….

LeftRightArrow

LeftRightArrow[x,y,…] displays as x↔y↔….

LeftRightVector

LeftRightVector[x,y,…] displays as x⥎y⥎….

LeftTee

LeftTee[x,y] displays as x⊣y.

LeftTeeArrow

LeftTeeArrow[x,y,…] displays as x↤y↤….

LeftTeeVector

LeftTeeVector[x,y,…] displays as x⥚y⥚….

LeftTriangle

LeftTriangle[x,y,…] displays as x⊲y⊲….

LeftTriangleBar

LeftTriangleBar[x,y,…] displays as x⧏y⧏….

LeftTriangleEqual

LeftTriangleEqual[x,y,…] displays as x⊴y⊴….

LeftUpDownVector

LeftUpDownVector[x,y,…] displays as x⥑y⥑….

LeftUpTeeVector

LeftUpTeeVector[x,y,…] displays as x⥠y⥠….

LeftUpVector

LeftUpVector[x,y,…] displays as x↿y↿….

LeftUpVectorBar

LeftUpVectorBar[x,y,…] displays as x⥘y⥘….

LeftVector

LeftVector[x,y,…] displays as x↼y↼….

LeftVectorBar

LeftVectorBar[x,y,…] displays as x⥒y⥒….

LegendAppearance

LegendAppearance is an option for charting functions that specifies the appearance of any legends that are generated.

Legended

Legended[expr,leg] displays expr with legend leg. 

Legended[expr,lbl] indicates in plotting and charting functions that a legend entry for expr should be created, with label lbl.

LegendFunction

LegendFunction is an option for legends that specifies an overall function to apply to the generated legend.

LegendLabel

LegendLabel is an option for legends that specifies an overall label for a legend.

LegendLayout

LegendLayout is an option for legends that specifies how to format the legend content.

LegendMargins

LegendMargins is an option for legends that specifies the margins to leave around the legend.

LegendMarkers

LegendMarkers is an option for legends such as PointLegend that specifies markers for each element.

LegendMarkerSize

LegendMarkerSize is an option for legends such as PointLegend that specifies the size of marker regions for each element.

Length

Length[expr] gives the number of elements in expr. 

LengthWhile

LengthWhile[list,crit] gives the number of contiguous elements ei starting at the beginning of list for which crit[ei] is True.

LerchPhi

LerchPhi[z,s,a] gives the Lerch transcendent Φ(z,s,a). 

Less

x<y yields True if x is determined to be less than y. 

x1<x2<x3 yields True if the xi form a strictly increasing sequence. 

LessEqual

x<=y or x≤y yields True if x is determined to be less than or equal to y.

x1≤x2≤x3 yields True if the xi form a nondecreasing sequence. 

LessEqualGreater

LessEqualGreater[x,y,…] displays as x⋚y⋚….

LessEqualThan

LessEqualThan[y] is an operator form that yields x≤y when applied to an expression x.

LessFullEqual

LessFullEqual[x,y,…] displays as x≦y≦….

LessGreater

LessGreater[x,y,…] displays as x≶y≶….

LessLess

LessLess[x,y,…] displays as x≪y≪….

LessSlantEqual

LessSlantEqual[x,y,…] displays as x⩽y⩽….

LessThan

LessThan[y] is an operator form that yields x<y when applied to an expression x.

LessTilde

LessTilde[x,y,…] displays as x≲y≲….

LetterCharacter

LetterCharacter represents a letter character in StringExpression.

LetterCounts

LetterCounts["string"] gives an association whose keys are the distinct letters in string, and whose values give the number of times those letters appear in string.

LetterCounts["string",n] gives counts of the distinct n-grams consisting of runs of n letters in string.

LetterCounts["string",n,{c1,c2,…}] allows the characters ci to appear in n-grams, in addition to ordinary letters.

LetterCounts[{string1,string2,…},…] gives the counts for each of the stringi.

LetterNumber

LetterNumber["c"] gives the position of the character c in the English alphabet.

LetterNumber["c",alpha] gives the position of c in the alphabet specified by alpha.

LetterNumber["string",…] gives a list of the positions of characters in string.

LetterQ

LetterQ[string] yields True if all the characters in the string are letters, and yields False otherwise. 

Level

Level[expr,levelspec] gives a list of all subexpressions of expr on levels specified by levelspec. 

Level[expr,levelspec,f] applies f to the sequence of subexpressions. 

LeviCivitaTensor

LeviCivitaTensor[d] gives the d-dimensional Levi-Civita totally antisymmetric tensor.

LevyDistribution

LevyDistribution[μ,σ] represents a Lévy distribution with location parameter μ and dispersion parameter σ.

LexicographicOrder

LexicographicOrder[{a1,a2,…},{b1,b2,…}] gives Order[ai,bi] for the first non-coinciding pair ai,bi of elements, and 0 if the lists are identical.

LexicographicOrder[{a1,a2,…},{b1,b2,…},p] uses the ordering function p to compare ai with bi.

LexicographicOrder[p] represents an operator form that compares lists when applied to {a1,a2,…}, {b1,b2,…}.

LexicographicSort

LexicographicSort[{e1,e2,…}] sorts the list of expressions ei in lexicographic order.

LexicographicSort[{e1,e2,…},p] compares elements of the ei expressions using the ordering function p.

LibraryDataType

LibraryDataType[datatype] specifies the data type for a LibraryFunction argument or result to be datatype.

LibraryDataType[datatype,etype] specifies an element type etype for data structures.

LibraryDataType[datatype,etype,d] specifies an array depth d for array data types.

LibraryFunction

LibraryFunction[args] represents a function that has been loaded from a Wolfram Library.

LibraryFunctionError

LibraryFunctionError[name,code] represents an error returned from a LibraryFunction.

LibraryFunctionInformation

LibraryFunctionInformation[fun] returns information about a LibraryFunction.

LibraryFunctionLoad

LibraryFunctionLoad[lib,fun,argtype,rettype] loads Wolfram Library lib and makes the library function fun available in the Wolfram Language.

LibraryFunctionUnload

LibraryFunctionUnload[fun] unloads a LibraryFunction so that it cannot be used.

LibraryUnload

LibraryUnload[lib] unloads all functions that have been loaded from a Wolfram Library, then it unloads the library.

LicenseEntitlementObject

LicenseEntitlementObject[…] represents an on-demand license entitlement.

LicenseEntitlementObject[id] gives the entitlement object representing the entitlement specified by id.

LicenseEntitlements

LicenseEntitlements[] gives a list of on-demand license entitlements owned by you.

LicenseID

LicenseID is an option to Encode which specifies the required value of $LicenseID on the computer that reads the encoded file. If no value is specified, any value of $LicenseID is allowed on the file-reading computer. A setting for LicenseID must be a string.

LicensingSettings

LicensingSettings is an option for RemoteBatchSubmit and related functions to configure licensing for remote kernels.

LiftingFilterData

LiftingFilterData[…] represents lifting-filter data used to compute forward and inverse lifting wavelet transforms.

LiftingWaveletTransform

LiftingWaveletTransform[data] gives the lifting wavelet transform (LWT) of an array of data.

LiftingWaveletTransform[data,wave] gives the lifting wavelet transform using the wavelet wave.

LiftingWaveletTransform[data,wave,r] gives the lifting wavelet transform using r levels of refinement.

LightBlue

LightBlue represents a light blue color in graphics or style specifications.

LightBrown

LightBrown represents a light brown color in graphics or style specifications.

LightCyan

LightCyan represents a light cyan color in graphics or style specifications.

Lighter

Lighter[color] represents a lighter version of the specified color. 

Lighter[color,f] represents a version of the specified color lightened by a fraction f. 

Lighter[image,…] gives a lighter version of an image.

Lighter[video,…] gives a version of a video with lighter frames.

LightGray

LightGray represents a light gray color in graphics or style specifications.

LightGreen

LightGreen represents a light green color in graphics or style specifications.

Lighting

Lighting is an option for Graphics3D and related functions that specifies what simulated lighting to use in coloring 3D surfaces. 

LightingAngle

LightingAngle is an option for ReliefPlot and related functions that specifies the angle from which simulated illumination is taken to come.

LightMagenta

LightMagenta represents a light magenta color in graphics or style specifications.

LightOrange

LightOrange represents a light orange color in graphics or style specifications.

LightPink

LightPink represents a light pink color in graphics or style specifications.

LightPurple

LightPurple represents a light purple color in graphics or style specifications.

LightRed

LightRed represents a light red color in graphics or style specifications.

LightSources

LightSources is an option for Graphics3D and related functions that specifies the properties of point light sources for simulated illumination. 

LightYellow

LightYellow represents a light yellow color in graphics or style specifications.

Likelihood

Likelihood[dist,{x1,x2,…}] gives the likelihood function for observations x1, x2, … from the distribution dist.

Likelihood[proc,{{t1,x1},{t2,x2},…}] gives the likelihood function for the observations xi at time ti from the process proc.

Likelihood[proc,{path1,path2,…}] gives the likelihood function for observations from path1, path2, … from the process proc.

Limit

Limit[f,x->x*] gives the limit x->x*f(x). 

Limit[f,{x1->x1*,…,xn->xn*}] gives the nested limit +x1->x1*⋯ +xn->xn*f(x1,…,xn). 

Limit[f,{x1,…,xn}->{x1*,…,xn*}] gives the multivariate limit +{x1,…,xn}->{x1*,…,xn*}f(x1,…,xn).

LimitsPositioningTokens

LimitsPositioningTokens is an option for selections that specifies a set of characters for which the option LimitsPositioning is set to True by default.

LindleyDistribution

LindleyDistribution[δ] represents a Lindley distribution with shape parameter δ.

Line

Line[{p1,p2,…}] represents the line segments joining a sequence for points pi.

Line[{{p11,p12,…},{p21,…},…}] represents a collection of lines. 

LinearFractionalOptimization

LinearFractionalOptimization[f,cons,vars] finds values of variables vars that minimize the linear fractional objective f subject to linear constraints cons.

LinearFractionalOptimization[{α,β,γ,δ},{a,b}] finds a vector x that minimizes the linear fractional function (α.x+β)/(γ.x+δ) subject to the linear inequality constraints a.x+b⪰0. 

LinearFractionalOptimization[{α,β,γ,δ},{a,b},{aeq,beq}] includes the linear equality constraints aeq.x+beq0.

LinearFractionalOptimization[{α,β,γ,δ},…,{dom1,dom2,…}] takes xi to be in the domain domi, where domi is Integers or Reals. 

LinearFractionalOptimization[…,"prop"] specifies what solution property "prop" should be returned.

LinearFractionalTransform

LinearFractionalTransform[m] gives a TransformationFunction that represents a linear fractional transformation defined by the homogeneous matrix m. 

LinearFractionalTransform[{a,b,c,d}] represents a linear fractional transformation that maps r to (a.r+b)/(c.r+d). 

LinearGradientFilling

LinearGradientFilling[{col1,col2,…,coln}] is a two-dimensional graphics directive specifying that faces of polygons and other filled graphics objects are to be drawn using a progressive transition between colors coli along a straight horizontal line.

LinearGradientFilling[{pos1,pos2,…,posn}->{col1,col2,…,coln}] uses the colors coli at the scaled positions posi.

LinearGradientFilling[{pos1,pos2,…,posn}->{col1,col2,…,coln},dir] draws along the straight line with a direction dir.

LinearGradientFilling[{pos1,…,posn}->{col1,…,coln},dir,padding] uses the specified padding when drawing beyond the boundary positions pos1 and posn. 

LinearGradientImage

LinearGradientImage[gcol] returns an image with values linearly changing from left to right based on gradient color gcol.

LinearGradientImage[{pos1,pos2}->gcol] returns an image where the gradient starts at pos1 and ends at pos2.

LinearGradientImage[…,size] returns a linear gradient image of the specified size.

LinearGradientImage[…,size,"type"] gives an image converted to the specified type.

LinearizingTransformationData

LinearizingTransformationData[…] represents data of an AffineStateSpaceModel linearized by functions such as FeedbackLinearize and StateTransformationLinearize using transformation of variables.

LinearLayer

LinearLayer[n] represents a trainable, fully connected net layer that computes w.x+b with output vector of size n. 

LinearLayer[{n1,n2,…}] represents a layer that outputs an array of dimensions n1×n2×….

LinearLayer[] leaves the dimensions of the output array to be inferred from context.

LinearLayer[n,opts] includes options for initial weights and other parameters. 

LinearModelFit

LinearModelFit[{{x1,y1},{x2,y2},…},{f1,f2,…},x] constructs a linear model of the form β0+β1f1+β2f2+… that fits the yi for successive xi values.

LinearModelFit[data,{f1,f2,…},{x1,x2,…}] constructs a linear model where the fi depend on the variables xk.

LinearModelFit[{m,v}] constructs a linear model from the design matrix m and response vector v.

LinearOffsetFunction

LinearOffsetFunction is an option for linear and generalized linear model fitting functions that specifies a component for the model that is to be assumed known.

LinearOptimization

LinearOptimization[f,cons,vars] finds values of variables vars that minimize the linear objective f subject to linear constraints cons.

LinearOptimization[c,{a,b}]  finds a real vector x that minimizes the linear objective c.x subject to the linear inequality constraints a.x+b⪰0.

LinearOptimization[c,{a,b},{aeq,beq}] includes the linear equality constraints aeq.x+beq0.

LinearOptimization[c,…,{dom1,dom2,…}] takes xi to be in the domain domi, where domi is Integers or Reals.

LinearOptimization[…,"prop"] specifies what solution property "prop" should be returned.

LinearProgramming

LinearProgramming[c,m,b] finds a vector x that minimizes the quantity c.x subject to the constraints m.x≥b and x≥0. 

LinearProgramming[c,m,{{b1,s1},{b2,s2},…}] finds a vector x that minimizes c.x subject to x≥0 and linear constraints specified by the matrix m and the pairs {bi,si}. For each row mi of m, the corresponding constraint is mi.x≥bi if si==1, or mi.x==bi if si==0, or mi.x≤bi if si==-1. 

LinearProgramming[c,m,b,l] minimizes c.x subject to the constraints specified by m and b and x≥l. 

LinearProgramming[c,m,b,{l1,l2,…}] minimizes c.x subject to the constraints specified by m and b and xi≥li. 

LinearProgramming[c,m,b,{{l1,u1},{l2,u2},…}] minimizes c.x subject to the constraints specified by m and b and li≤xi≤ui. 

LinearProgramming[c,m,b,lu,dom] takes the elements of x to be in the domain dom, either Reals or Integers.

LinearProgramming[c,m,b,lu,{dom1,dom2,…}] takes xi to be in the domain domi.

LinearSolve

LinearSolve[m,b] finds an x that solves the matrix equation m.x==b. 

LinearSolve[m] generates a LinearSolveFunction[…] that can be applied repeatedly to different b. 

LinearSolve[a,b] finds an x that solves the array equation a.x==b. 

LinearSolveFunction

LinearSolveFunction[dimensions,data] represents a function for providing solutions to a matrix equation. 

LinebreakAdjustments

LinebreakAdjustments is an option for selections that sets parameters used for calculating where automatic line breaks should be inserted.

LineBreakChart

LineBreakChart[{{date1,p1},{date2,p2},…}] makes a line break chart with prices pi at date datei.

LineBreakChart[{"name",daterange}] makes a line break chart of closing prices for the financial entity "name" over the date range daterange.

LineBreakChart[{…},n] makes a line break chart where n bars in a row cause a reversal.

LineBreakWithin

LineBreakWithin is an option for selections that specifies whether line breaks occur automatically when the end of a line is reached.

LineGraph

LineGraph[g] gives the line graph of the graph g.

LineGraph[{v->w,…}] uses rules v->w to specify the graph g.

LineIndent

LineIndent is an option for Style and Cell that specifies how many ems of indentation to add at the beginnings of lines for each level of nesting in an expression. 

LineIntegralConvolutionPlot

LineIntegralConvolutionPlot[{{vx,vy},image},{x,xmin,xmax},{y,ymin,ymax}] generates a line integral convolution plot of image convolved with the vector field {vx,vy} as a function of x and y.

LineIntegralConvolutionPlot[{vx,vy},{x,xmin,xmax},{y,ymin,ymax}] generates a line integral convolution plot of white noise with the vector field {vx,vy}.

LineIntegralConvolutionScale

LineIntegralConvolutionScale is an option to LineIntegralConvolutionPlot and related functions that determines the scale of the line integral convolution to be used.

LineLegend

LineLegend[{col1,…},{lbl1,…}] generates a legend that associates color coli with label lbli.

LineLegend[{col1,…},Automatic] generates a legend with placeholder labels for the colors coli.

LineLegend[{lbl1,…}] represents a legend with inherited colors within visualization functions.

LineSpacing

LineSpacing is an option for Style and Cell that specifies the spacing between successive lines of text. 

LinkActivate

LinkActivate[lnk] activates a WSTP connection, waiting for the program at the other end to respond.

LinkClose

LinkClose[link] closes an open WSTP connection. 

LinkConnect

LinkConnect["name"] connects to a WSTP link created by another program. 

LinkCreate

LinkCreate["name"] creates a WSTP link with the specified name for another program to connect to. 

LinkCreate[] creates a WSTP link and picks an unused name for the link.

LinkError

LinkError[link] returns error information for link in the form { errorNumber, errorExplanation }.

LinkFlush

LinkFlush[link] transmits immediately any locally buffered outgoing expressions.

LinkFunction

LinkFunction is an option for GeneralizedLinearModelFit that specifies the link function for the generalized linear model.

LinkHost

LinkHost is an option for LinkOpen that specifies on what computer a program should be launched or on what computer a listening link will be found.

LinkInterrupt

LinkInterrupt[link] sends an interrupt to the program at the other end of the specified WSTP connection. 

LinkLaunch

LinkLaunch["prog"] starts the external program prog and opens a WSTP connection to it. 

LinkMode

LinkMode is an option for LinkOpen that specifies how the link is to be established and connected.  The possible settings for LinkMode are Launch, Listen, Connect, and Loopback.

LinkObject

LinkObject["name",n1,n2] is an object that represents an active WSTP connection for functions such as LinkRead and LinkWrite. 

LinkOpen

LinkOpen["prog"] starts the external program prog and opens a MathLink connection to it.

LinkPatterns

LinkPatterns[link] gives a list of the patterns for which definitions were set up when the external program associated with the specified WSTP connection was installed. 

LinkProtocol

LinkProtocol is an option to LinkLaunch, Install, and related functions that specifies the underlying data transport protocol to use for a new WSTP link. 

LinkRankCentrality

LinkRankCentrality[g,α] gives the link-rank centralities for edges in the graph g and weight α.

LinkRankCentrality[g,α,β] gives the link-rank centralities, using weight α and initial vertex page-rank centralities β.

LinkRankCentrality[{v->w,…},…] uses rules v->w to specify the graph g.

LinkRead

LinkRead[link] reads one expression from the specified WSTP connection. 

LinkRead[link,h] wraps h around the expression read before evaluating it. 

LinkReadHeld

LinkReadHeld[link] reads an expression via WSTP from link and returns it wrapped in Hold.

LinkReadyQ

LinkReadyQ[link] tests whether there is an expression ready to read from the specified WSTP connection. 

LinkReadyQ[link,t] waits for up to t seconds to see if an expression becomes ready to read.

LinkReadyQ[{link1,link2,…},t] tests all the linki in parallel, returning as soon as any of them are ready to read from.

Links

Links[] gives a list of all WSTP connections that are currently open. 

Links[patt] lists only links whose names match the specified string pattern.

LinkService

LinkService["service", l] is an object that represents an active connection to the WSTP service.

LinkWrite

LinkWrite[link,expr] writes expr to the specified WSTP connection. 

LinkWriteHeld

LinkWriteHeld[link, Hold[expr], (flush:True)] writes expr (without the Hold) via WSTP to link (synchronizing unless flush is False).

LiouvilleLambda

LiouvilleLambda[n] gives the Liouville function λ(n).

List

{e1,e2,…} is a list of elements. 

Listable

Listable is an attribute that can be assigned to a symbol f to indicate that the function f should automatically be threaded over lists that appear as its arguments. 

ListAnimate

ListAnimate[{expr1,expr2,…}] generates an animation whose frames are images expr_Imagei.

ListContourPlot

ListContourPlot[{{f11,…,f1n},…,{fm1,…,fmn}}] generates a contour plot from an array of values fij.

ListContourPlot[{{x1,y1,f1},…,{xk,yk,fk}}] generates a contour plot from values fi specified at points {xi,yi}. 

ListContourPlot3D

ListContourPlot3D[farr] generates a contour plot from an array farr with values farr[[i,j,k]] at points {k,j,i}.

ListContourPlot3D[{{x1,y1,z1,f1},{x2,y2,z2,f2},…}] generates a contour plot from values fi at point {xi,yi,zi}. 

ListCurvePathPlot

ListCurvePathPlot[{{x1,y1},{x2,y2},…}] plots a curve that corresponds to a smooth path through the specified points. 

ListDeconvolve

ListDeconvolve[ker,list] gives a deconvolution of list using kernel ker.

ListDensityPlot

ListDensityPlot[{{f11,…,f1n},…,{fm1,…,fmn}}] generates a smooth density plot from an array of values fij.

ListDensityPlot[{{x1,y1,f1},…,{xk,yk,fk}}] generates a density plot with values fi defined at specified points {xi,yi}. 

ListDensityPlot3D

ListDensityPlot3D[farr] generates a smooth density plot from an array of values farr. 

ListDensityPlot3D[{{x1,y1,z1,f1},…,{xn,yn,zn,fn}}] generates a density plot with values fi at the specified points {xi,yi,zi}.

Listen

Listen is a setting for the LinkMode option of LinkOpen.  LinkMode->Listen causes a link to be created that listens on a named port for an incoming connection request.

ListFormat

ListFormat is an option to TextString and related functions that determines how lists are formatted.

ListFourierSequenceTransform

ListFourierSequenceTransform[list,ω] gives the discrete-time Fourier transform (DTFT) of a list as a function of the parameter ω.

ListFourierSequenceTransform[list,ω,k] places the first element of list at integer time k on the infinite time axis.

ListFourierSequenceTransform[list,{ω1,ω2,…},{k1,k2,…}] gives the multidimensional discrete-time Fourier transform

ListInterpolation

ListInterpolation[array] constructs an InterpolatingFunction object that represents an approximate function that interpolates the array of values given. 

ListInterpolation[array,{{xmin,xmax},{ymin,ymax},…}] specifies the domain of the grid from which the values in array are assumed to come. 

ListLineIntegralConvolutionPlot

ListLineIntegralConvolutionPlot[{array,image}] generates a line integral convolution plot of image convolved with the vector field defined by an array of vector field values.

ListLineIntegralConvolutionPlot[array] generates a line integral convolution plot of white noise convolved with the vector field defined by array.

ListLineIntegralConvolutionPlot[{{{{x1,y1},{vx1,vy1}},…},image}] generates a line integral convolution plot of image convolved with the vector field defined by vectors {vxi,vyi} at specified points {xi,yi}.

ListLineIntegralConvolutionPlot[{{{x1,y1},{vx1,vy1}},…}] generates a line integral convolution plot of white noise convolved with the vector field defined by {vxi,vyi}.

ListLinePlot

ListLinePlot[{y1,…,yn}] plots a line through the points {1,y1}, …, {n,yn}.

ListLinePlot[{{x1,y1},…,{xn,yn}}] plots a line through the points {x1,y1}, …, {xn,yn}.

ListLinePlot[{data1,data2,…}] plots lines from all the datai. 

ListLinePlot[{…,w[datai,…],…}] plots datai with features defined by the symbolic wrapper w.

ListLinePlot3D

ListLinePlot3D[{{x1,y1,z1},{x2,y2,z2},…,{xn,yn,zn}}] plots a curve through the 3D points {xi,yi,zi}.

ListLinePlot3D[{{z11,z12,…,z1n},…,{zm1,zm2,…,zmn}}] plots each row {zi1,zi2,…,zin} as a curve in the x direction, with successive curves stacked in the y direction. 

ListLinePlot3D[{data1,data2,…}] plots curves through multiple sets of {x,y,z} points.

ListLogLinearPlot

ListLogLinearPlot[{y1,y2,…}] makes a log-linear plot of the yi, assumed to correspond to x coordinates 1, 2, ….

ListLogLinearPlot[{{x1,y1},{x2,y2},…}] makes a log-linear plot of the specified list of x and y values.

ListLogLinearPlot[{list1,list2,…}] plots several lists of values.

ListLogLinearPlot[{…,w[datai,…],…}] plots datai with features defined by the symbolic wrapper w. 

ListLogLogPlot

ListLogLogPlot[{y1,y2,…}] makes a log-log plot of the yi, assumed to correspond to x coordinates 1, 2, ….

ListLogLogPlot[{{x1,y1},{x2,y2},…}] makes a log-log plot of the specified list of x and y values.

ListLogLogPlot[{data1,data2,…}] plots data from all the datai.

ListLogLogPlot[{…,w[datai,…],…}] plots datai with features defined by the symbolic wrapper w. 

ListLogPlot

ListLogPlot[{y1,y2,…}] makes a log plot of the yi, assumed to correspond to x coordinates 1, 2, ….

ListLogPlot[{{x1,y1},{x2,y2},…}] makes a log plot of the specified list of x and y values.

ListLogPlot[{data1,data2,…}] plots data from all the datai.

ListLogPlot[{…,w[datai,…],…}] plots datai with features defined by the symbolic wrapper w. 

ListPlay

ListPlay[{a1,a2,…}] creates an object that plays as a sound whose amplitude is given by the sequence of levels ai. 

ListPlot

ListPlot[{y1,…,yn}] plots regularly spaced points {i,yi}.

ListPlot[{{x1,y1},…,{xn,yn}}] generates a scatter plot with points {xi,yi}.

ListPlot[{data1,data2,…}] plots points from all the datai.

ListPlot[{…,w[datai,…],…}] plots datai with features defined by the symbolic wrapper w. 

ListPlot3D

ListPlot3D[{{f11,…,f1n},…,{fm1,…,fmn}}] generates a surface with height fij at {x,y} position {j,i}. 

ListPlot3D[{{x1,y1,f1},…,{xk,yk,fk}}] generates a surface with height fi at {x,y} position {xi,yi}. 

ListPlot3D[{data1,data2,…}] plots the surfaces corresponding to each of the datai.

ListPointPlot3D

ListPointPlot3D[{{x1,y1,z1},{x2,y2,z2},…}] generates a 3D scatter plot of points with coordinates {xi,yi,zi}. 

ListPointPlot3D[array] generates a 3D scatter plot of points with a 2D array of height values.

ListPointPlot3D[{data1,data2,…}] plots several collections of points, by default in different colors. 

ListPolarPlot

ListPolarPlot[{r1,r2,…}] plots points equally spaced in angle at radii ri.

ListPolarPlot[{{θ1,r1},{θ2,r2},…}] plots points at polar coordinates θi, ri.

ListPolarPlot[{list1,list2,…}] plots several lists of values.

ListQ

ListQ[expr] gives True if the head of expr is List, and False otherwise.

ListSliceContourPlot3D

ListSliceContourPlot3D[farr,surf] generates a contour plot of the three-dimensional farr of values sliced to the surface surf.

ListSliceContourPlot3D[{{x1,y1,z1,f1},{x2,y2,z2,f2},…},surf] generates a slice contour plot for the values fi at points {xi,yi,zi}.

ListSliceContourPlot3D[…,{surf1,surf2,…}] generates slice contour plots over several slices surf1, surf2, ….

ListSliceDensityPlot3D

ListSliceDensityPlot3D[farr,surf] generates a density plot of the three-dimensional farr of values sliced to the surface surf.

ListSliceDensityPlot3D[{{x1,y1,z1,f1},{x2,y2,z2,f2},…},surf] generates a slice density plot for the values fi at points {xi,yi,zi}.

ListSliceDensityPlot3D[…,{surf1,surf2,…}] generates slice density plots over several slices surf1, surf2, ….

ListSliceVectorPlot3D

ListSliceVectorPlot3D[varr,surf] generates a vector plot from a 3D array varr of vector field values over the slice surface surf.

ListSliceVectorPlot3D[…,{surf1,surf2,…}] generates a slice vector plot over several surfaces surf1, surf2, …. 

ListStepPlot

ListStepPlot[{y1,y2,…}] plots the values y1, y2, … in steps at points 1, 2, ….

ListStepPlot[{{x1,y1},{x2,y2},…}] plots the values y1, y2, … in steps at points x1, x2, ….

ListStepPlot[{data1,data2,…}] plots data from all the datai.

ListStepPlot[data,step] plots using steps specified by step.

ListStepPlot[{…,w[datai,…],…}] plots datai with features defined by the symbolic wrapper w. 

ListStreamDensityPlot

ListStreamDensityPlot[varr] generates a stream density plot from an array varr of vector and scalar field values {{vxij,vyij},rij}. 

ListStreamDensityPlot[{{{x1,y1},{{vx1,vy1},r1}},…}] generates a stream density plot from vector and scalar field values {{vxi,vyi},ri} given at specified points {xi,yi}.

ListStreamDensityPlot[{data1,data2,…}] plots data for several vector and scalar fields. 

ListStreamPlot

ListStreamPlot[varr] generates a stream plot from an array varr of vectors.

ListStreamPlot[{{{x1,y1},{vx1,vy1}},…}] generates a stream plot from vectors {vxi,vyi} given at points {xi,yi}.

ListStreamPlot[{data1,data2,…}] plots data for several vector fields. 

ListStreamPlot3D

ListStreamPlot3D[varr] plots streamlines for the vector field given as an array of vectors.

ListSurfacePlot3D

ListSurfacePlot3D[{{x1,y1,z1},{x2,y2,z2},…}] plots a three-dimensional surface constructed to fit the specified points. 

ListVectorDensityPlot

ListVectorDensityPlot[varr] generates a vector density plot from an array varr of vector and scalar field values {{vxij,vyij},rij}. 

ListVectorDensityPlot[{{{x1,y1},{{vx1,vy1},r1}},…}] generates a vector density plot from vector and scalar field values {{vxi,vyi},ri} given at specified points {xi,yi}.

ListVectorDensityPlot[{data1,data2,…}] plots data for several vector and scalar fields. 

ListVectorDisplacementPlot

ListVectorDisplacementPlot[{{{vx11,vy11},…,{vx1n,vy1n}},…,{{vxm1,vym1},…,{vxmn,vymn}}}] generates a displacement plot from an array of vector displacements {vxij,vyij}.

ListVectorDisplacementPlot[{{{x1,y1},{vx1,vy1}},…,{{x1,y1},{vx1,vy1}}}] generates a displacement plot from displacements {vxi,vyi} at point {xi,yi}.

ListVectorDisplacementPlot[{{ {{vx11,vy11},s11},…,{{vx1n,vy1n},s1n}},…,{ {{vxmi,vym1},sm1},…,{{vxmn,vymn},smn}}}] uses the scalar values sij to color the displaced region.

ListVectorDisplacementPlot[{ {{vx1,vy1},s1},…,{{vxn,vyn},sn}}] uses the scalar values si at point {xi,yi} to color the displaced region.

ListVectorDisplacementPlot[…,reg] plots the displacement over the region reg.

ListVectorDisplacementPlot3D

ListVectorDisplacementPlot3D[{{{vx11,vy11,vz11},…,{vx1n,vy1n,vz1n}},…,{{vxm1,vym1,vzm1},…,{vxmn,vymn,vzmn}}}] generates a displacement plot from an array of vector displacements {vxij,vyij,vzij}.

ListVectorDisplacementPlot3D[{{{x1,y1,z1},{vx1,vy1,vz1}},…,{{xn,yn,zn},{vxn,vyn,vzn}}}] generates a displacement plot from displacements {vxi,vyi,vzi} at point {xi,yi,zi}.

ListVectorDisplacementPlot3D[{{{{vx11,vy11,vz11},s11},…,{{vx1n,vy1n,vz1n},s1n}},…,{{{vxm1,vym1,vzm1},sm1},…,{{vxmn,vymn,vzmn},smn}}] uses the scalar values sij to color the displaced region.

ListVectorDisplacementPlot3D[{{{x1,y1,z1},{{vx1,vy1,vz1},s1}},…,{{xn,yn,zn},{{vxn,vyn,vzn},sn}}}] uses the scalar values si at point {xi,yi,zi} to color the displaced region.

ListVectorDisplacementPlot3D[…,reg] plots the displacement over the region reg.

ListVectorPlot

ListVectorPlot[varr] generates a vector plot from an array varr of vectors.

ListVectorPlot[{{{x1,y1},{vx1,vy1}},…}] generates a vector plot from vectors {vxi,vyi} given at specified points {xi,yi}.

ListVectorPlot[{data1,data2,…}] plots data for several vector fields. 

ListVectorPlot3D

ListVectorPlot3D[varr] generates a 3D vector plot from a 3D array of vector field values.

ListVectorPlot3D[{data1,data2,…}] plots data for several vector fields. 

ListZTransform

ListZTransform[list,z] gives the Z transform of list as a function of z.

ListZTransform[list,z,k] places the first element of list at integer time k on the infinite time axis.

ListZTransform[list,{z1,z2,…},{k1,k2,…}] gives the multidimensional Z transform.

LocalAdaptiveBinarize

LocalAdaptiveBinarize[image,r] creates a binary image from image by replacing values above the mean of the range-r neighborhood with 1 and others with 0.

LocalAdaptiveBinarize[image,r,{α,β,γ}] replaces values above α μ+β σ+γ with 1 and others with 0, where μ and σ are the local mean and standard deviation.

LocalClusteringCoefficient

LocalClusteringCoefficient[g] gives the list of local clustering coefficients of all vertices in the graph g.

LocalClusteringCoefficient[g,v] gives the local clustering coefficient of the vertex v in the graph g.

LocalClusteringCoefficient[{v->w,…},…] uses rules v->w to specify the graph g.

LocalizeVariables

LocalizeVariables is an option to Manipulate that determines whether the values of variables associated with controls should be localized.

LocalObject

LocalObject[] represents a new anonymous local object.

LocalObject["file:///…"] represents a local object with a given file path.

LocalObject["relpath"] represents a local object with the given relative path.

LocalObject["relpath","lbase"] represents a local object relative to the base lbase.

LocalObjects

LocalObjects[] gives a list of local objects in your current local base directory.

LocalObjects[dir] gives a list of local objects in the local directory dir.

LocalResponseNormalizationLayer

LocalResponseNormalizationLayer[] represents a net layer that normalizes its input by averaging across neighboring input channels.

LocalSubmit

LocalSubmit[expr] submits a task to evaluate expr in a separate kernel.

LocalSubmit[ScheduledTask[expr, spec]] submits a task to evaluate expr in a separate kernel on the schedule defined by spec.

LocalSymbol

LocalSymbol["name"] represents a symbol whose value is persistently stored in the local file system.

LocalSymbol[obj] represents a persistent symbol corresponding to the local object obj.

LocalTime

LocalTime[] gives a DateObject corresponding to the current local time at the current geo location.

LocalTime[loc] gives the current local time at the geo location specified by loc.

LocalTime[loc,time] gives the local time corresponding to the date object time at the geo location loc.

LocalTime[loc,time,func] uses func to determine what to return for extended geographic regions.

LocalTimeZone

LocalTimeZone[] gives the current time zone for the current geo location.

LocalTimeZone[loc] gives the current time zone for the geo location specified by loc.

LocalTimeZone[loc,date] gives the time zone for the geo location loc on the specified date.

LocalTimeZone[loc,date,"prop"] gives the specified property of the time zone.

LocationEquivalenceTest

LocationEquivalenceTest[{data1,data2,…}] tests whether the means or medians of the datai are equal. 

LocationEquivalenceTest[{data1,…},"property"] returns the value of "property".

LocationTest

LocationTest[data] tests whether the mean or median of the data is zero. 

LocationTest[{data1,data2}] tests whether the means or medians of data1 and data2 are equal.

LocationTest[dspec,μ0] tests a location measure against μ0.

LocationTest[dspec,μ0,"property"] returns the value of "property".

LocatorAutoCreate

LocatorAutoCreate is an option for LocatorPane, Manipulate, and related functions that specifies whether new locators should be created when clicking away from existing locators.

LocatorRegion

LocatorRegion is an option for Locator that specifies where the locator object should by default be allowed to go when it is dragged.

Locked

Locked is an attribute that, once assigned, prevents modification of any attributes of a symbol. 

Log

Log[z] gives the natural logarithm of z (logarithm to base e). 

Log[b,z] gives the logarithm to base b. 

Log10

Log10[x] gives the base-10 logarithm of x.

Log2

Log2[x] gives the base-2 logarithm of x.

LogBarnesG

LogBarnesG[z] gives the logarithm of the Barnes G-function logG(z).

LogGamma

LogGamma[z] gives the logarithm of the gamma function log Γ(z). 

LogGammaDistribution

LogGammaDistribution[α,β,μ] represents a log-gamma distribution with shape parameters α and β and location parameter μ.

LogicalExpand

LogicalExpand[expr] expands out logical combinations of equations, inequalities, and other functions. 

LogIntegral

LogIntegral[z] is the logarithmic integral function li(z). 

LogisticDistribution

LogisticDistribution[μ,β] represents a logistic distribution with mean μ and scale parameter β.

LogisticDistribution[] represents a logistic distribution with mean 0 and scale parameter 1.

LogisticSigmoid

LogisticSigmoid[z] gives the logistic sigmoid function.

LogLikelihood

LogLikelihood[dist,{x1,x2,…}] gives the log‐likelihood function for observations x1, x2, … from the distribution dist.

LogLikelihood[proc,{{t1,x1},{t2,x2},…}] gives the log-likelihood function for the observations xi at time ti from the process proc.

LogLikelihood[proc,{path1,path2,…}] gives the log-likelihood function for the observations from path1, path2, … from the process proc.

LogLinearPlot

LogLinearPlot[f,{x,xmin,xmax}] generates a log-linear plot of f as a function of x from xmin to xmax. 

LogLinearPlot[{f1,f2,…},{x,xmin,xmax}] plots several functions fi. 

LogLinearPlot[{…,w[fi],…},…] plots fi with features defined by the symbolic wrapper w.

LogLinearPlot[…,{x}∈reg] takes the variable x to be in the geometric region reg.

LogLogisticDistribution

LogLogisticDistribution[γ,σ] represents a log-logistic distribution with shape parameter γ and scale parameter σ.

LogLogPlot

LogLogPlot[f,{x,xmin,xmax}] generates a log-log plot of f as a function of x from xmin to xmax. 

LogLogPlot[{f1,f2,…},{x,xmin,xmax}] plots several functions fi. 

LogLogPlot[{…,w[fi],…},…] plots fi with features defined by the symbolic wrapper w.

LogLogPlot[…,{x}∈reg] takes the variable x to be in the geometric region reg.

LogMultinormalDistribution

LogMultinormalDistribution[μ,Σ] represents a log-multinormal distribution with parameters μ and Σ.

LogNormalDistribution

LogNormalDistribution[μ,σ] represents a lognormal distribution derived from a normal distribution with mean μ and standard deviation σ.

LogPlot

LogPlot[f,{x,xmin,xmax}] generates a log plot of f as a function of x from xmin to xmax. 

LogPlot[{f1,f2,…},{x,xmin,xmax}] plots several functions fi. 

LogPlot[{…,w[fi],…},…] plots fi with features defined by the symbolic wrapper w.

LogPlot[…,{x}∈reg] takes the variable x to be in the geometric region reg.

LogRankTest

LogRankTest[{data1,data2,…}] tests for equal hazard rates among the datai using a log-rank type test. 

LogRankTest[{data1,data2,…},wspec] performs a weighted log-rank test with weights wspec. 

LogRankTest[{data1,…},wspec,"property"] returns the value of "property".

LogSeriesDistribution

LogSeriesDistribution[θ] represents a logarithmic series distribution with parameter θ.

Longest

Longest[p] is a pattern object that matches the longest sequence consistent with the pattern p. 

LongestCommonSequence

LongestCommonSequence[s1,s2] finds the longest sequence of contiguous or disjoint elements common to the strings or lists s1 and s2.

LongestCommonSequence[s1,s2] finds the longest sequence of contiguous or disjoint elements common to the strings, lists or biomolecular sequences s1 and s2.

LongestCommonSequencePositions

LongestCommonSequencePositions[s1,s2] finds the longest sequence of contiguous or disjoint elements common to the strings or lists s1 and s2 and returns their positions.

LongestCommonSequencePositions[s1,s2] finds the longest sequence of contiguous or disjoint elements common to the strings, lists or biomolecular sequences s1 and s2 and returns their positions.

LongestCommonSubsequence

LongestCommonSubsequence[s1,s2] finds the longest contiguous subsequence of elements common to the strings or lists s1 and s2.

LongestCommonSubsequence[s1,s2] finds the longest contiguous subsequence of elements common to the strings, biomolecular sequences or lists s1 and s2.

LongestCommonSubsequencePositions

LongestCommonSubsequencePositions[s1,s2] finds the longest contiguous subsequence of elements common to the strings or lists s1 and s2 and returns their positions {pos1,pos2} in s1 and s2.

LongestCommonSubsequencePositions[s1,s2] finds the longest contiguous subsequence of elements common to the strings, biomolecular sequences or lists s1 and s2 and returns their positions {pos1,pos2} in s1 and s2.

LongestMatch

LongestMatch[p] is a string pattern object matching the longest sequence of characters consistent with the string pattern p.

LongestOrderedSequence

LongestOrderedSequence[list] finds the longest ordered sequence of contiguous or disjoint elements in list.

LongestOrderedSequence[list,p] finds the longest ordered sequence using the ordering function p.

LongForm

LongForm is an option for Information. With LongForm -> True, the full information of a symbol is printed. With LongForm -> False the usage of a symbol is printed.

Longitude

Longitude[pos] gives the longitude in degrees of a geographic position specified by pos.

Longitude[pos,datum] gives the longitude referring to the specified geodetic datum.

LongLeftArrow

LongLeftArrow[x,y,…] displays as x⟵y⟵….

LongLeftRightArrow

LongLeftRightArrow[x,y,…] displays as x⟷y⟷….

LongRightArrow

LongRightArrow[x,y,…] displays as x⟶y⟶….

LongShortTermMemoryLayer

LongShortTermMemoryLayer[n] represents a trainable recurrent layer that takes a sequence of vectors and produces a sequence of vectors, each of size n.

LongShortTermMemoryLayer[n,opts] includes options for weights and other parameters. 

Lookup

Lookup[assoc,key] looks up the value associated with key in the association assoc; if the key is not present, Missing["KeyAbsent",key] is returned.

Lookup[assoc,{key1,key2,…}] gives a list of the values associated with the keyi.

Lookup[{assoc1,assoc2,…},key] gives a list corresponding to the value of key in each associ.

Lookup[assoc,key,default] gives default if the key is not present.

Lookup[assoc,keys,default,h] looks up the values associated with keys, wrapping each of them with head h before evaluation.

Lookup[key] represents an operator form of Lookup that can be applied to an expression.

Loopback

Loopback is a setting for the LinkMode option of LinkOpen.  LinkMode->Loopback causes a link to be created that is not connected to another program.  Expressions written to the link are read back from the same link.

LoopFreeGraphQ

LoopFreeGraphQ[g] yields True if the graph g has no self-loops, and False otherwise.

Looping

Looping is an option for VideoStream, AudioStream and related functions to specify the playback looping.

LossFunction

LossFunction is an option for NetTrain that specifies how to compare actual and requested outputs from a neural net.

LowerCaseQ

LowerCaseQ[string] yields True if all the characters in the string are lowercase letters, and yields False otherwise. 

LowerLeftArrow

LowerLeftArrow[x,y,…] displays as x↙y↙….

LowerRightArrow

LowerRightArrow[x,y,…] displays as x↘y↘….

LowpassFilter

LowpassFilter[data,ωc] applies a lowpass filter with a cutoff frequency ωc to an array of data.

LowpassFilter[data,ωc,n] uses a filter kernel of length n.

LowpassFilter[data,ωc,n,wfun] applies a smoothing window wfun to the filter kernel.

LQEstimatorGains

LQEstimatorGains[ssm,{w,v}] gives the optimal estimator gain matrix for the StateSpaceModel ssm, with process and measurement noise covariance matrices w and v.

LQEstimatorGains[ssm,{w,v,h}] includes the cross-covariance matrix h.

LQEstimatorGains[{ssm,sensors},{…}] specifies sensors as the noisy measurements of ssm.

LQEstimatorGains[{ssm,sensors,dinputs},{…}] specifies dinputs as the deterministic inputs of ssm.

LQGRegulator

LQGRegulator[sspec,cvs,wts] gives the optimal output feedback controller for the stochastic system specification sspec with noise covariance matrices cvs that minimizes a cost function with weights wts.

LQGRegulator[…,"prop"] gives the value of the property "prop".

LQOutputRegulatorGains

LQOutputRegulatorGains[sspec,wts] gives the state feedback gains for the system specification sspec that minimizes an output cost function with weights wts.

LQOutputRegulatorGains[…,"prop"] gives the value of the property "prop".

LQRegulatorGains

LQRegulatorGains[sspec,wts] gives the state feedback gains for the system specification sspec that minimizes a cost function with weights wts.

LQRegulatorGains[…,"prop"] gives the value of the property "prop".

LucasL

LucasL[n] gives the Lucas number Ln.

LucasL[n,x] gives the Lucas polynomial Ln(x).

LuccioSamiComponents

LuccioSamiComponents[g] gives the Luccio–Sami components of the graph g.

LuccioSamiComponents[g,{v1,v2,…}] gives the components that include at least one of the vertices v1, v2, … .

LuccioSamiComponents[{v->w,…},…] uses rules v->w to specify the graph g.

LUDecomposition

LUDecomposition[m] generates a representation of the LU decomposition of a square matrix m. 

LunarEclipse

LunarEclipse[] gives the time of the next lunar eclipse.

LunarEclipse[datespec] gives the time for the next lunar eclipse after the specified date.

LunarEclipse[propertyspec] gives the specified property value for the next lunar eclipse.

LunarEclipse[datespec,propertyspec] gives the specified property value for the next lunar eclipse after the specified date.

LUVColor

LUVColor[l,u,v] represents a color in the LUV color space with lightness l and color components u and v.

LUVColor[l,u,v,a] specifies opacity a. 

LUVColor["string"] returns a color from an HTML color name etc.

LUVColor[color] returns the LUV representation of color.

LyapunovSolve

LyapunovSolve[a,c] finds a solution x of the matrix Lyapunov equation a.x+x.ac.

LyapunovSolve[a,b,c] solves a.x+x.bc.

LyapunovSolve[{a,d},c] solves a.x.d+d.x.ac.

LyapunovSolve[{a,d},{b,e},c] solves a.x.e+d.x.bc.

LyonsGroupLy

LyonsGroupLy[] represents the sporadic simple Lyons group Ly.

MachineID

MachineID is an option to Encode which specifies the required value of $MachineID on the computer that reads the encoded file. If no value is specified, any value of $MachineID is allowed on the file-reading computer. A setting for MachineID must be a string.

MachineName

MachineName is an option to Encode which specifies the required value of $MachineName on the computer that reads the encoded file. If no value is specified, any value of $MachineName is allowed on the file-reading computer. A setting for MachineName must be a string.

MachineNumberQ

MachineNumberQ[expr] returns True if expr is a machine‐precision real or complex number, and returns False otherwise. 

MachinePrecision

MachinePrecision is a symbol used to indicate machine‐number precision. 

Magenta

Magenta represents the color magenta in graphics or style specifications. 

Magnification

Magnification is an option for Style and Cell that specifies what magnification to use for display. 

Magnify

Magnify[expr,r] represents an object to be displayed with magnification r. 

Magnify[expr] displays with expr magnified by a fixed factor.

MailAddressValidation

MailAddressValidation is an option for SendMail that specifies whether and how to validate email addresses.

MailExecute

MailExecute[cmd,target] executes the mail command cmd on the target mail server connection, folder, file or item(s).

MailFolder

MailFolder[…] represents a mail folder associated with an active mail server connection.

MailItem

MailItem[…] represents an item of mail associated with an active mail server connection.

MailReceiverFunction

MailReceiverFunction[fun] represents a mail receiver function that applies fun to any mail message it receives.

MailResponseFunction

MailResponseFunction is an option for MailReceiverFunction that specifies what function to apply to respond to the sender of mail received by a MailReceiverFunction.

MailSearch

MailSearch[folder,assoc] searches the specified mail folder for messages with properties matching elements in assoc.

MailSearch[assoc] searches the current default mail inbox.

MailSearch[] gives the list of unread messages in the current default mail inbox.

MailServerConnect

MailServerConnect[] connects to your default incoming mail server.

MailServerConnect["server"] connects to the specified incoming mail server "server".

MailServerConnect["server",userid] connects using the specified user ID userid.

MailServerConnect["server",userid,password] connects using userid and password.

MailServerConnection

MailServerConnection[…] is a symbolic representation of a connection to an incoming mail server.

MailSettings

MailSettings is an option for SendMail and MailServerConnect to specify mail settings.

MainSolve

MainSolve[eqns] is the underlying function for transforming systems of equations. Solve and Eliminate call it. The equations must be of the form lhs == rhs. They can be combined using && and ||. MainSolve returns False if no solutions to the equations exist, and True if all values of variables are solutions. MainSolve rearranges the equations using certain directives. MainSolve[eqns, vars, elim, rest] attempts to rearrange the equations eqns so as to solve for the variables vars, and eliminate the variables elim. The list rest can be included to specify the elimination order for any remaining variables.

Majority

Majority[e1,e2,…] gives True if the majority of the ei are True, and False if the majority are False.

MakeRules

MakeRules is an option to Solve and related functions. With MakeRules -> True, the result is presented as an AlgebraicRulesData object. With MakeRules -> False, the result is presented as a list of rules.

ManagedLibraryExpressionID

ManagedLibraryExpressionID[expr] returns the positive integer ID associated with expr if it is a managed library expression and $Failed otherwise.

ManagedLibraryExpressionID[expr,mname] only returns the ID if expr is associated with the registered manager having name mname.

ManagedLibraryExpressionQ

ManagedLibraryExpressionQ[expr] returns True if expr is a managed library expression and False otherwise.

ManagedLibraryExpressionQ[expr,mname] only returns True if expr is associated with the registered manager having name mname.

MandelbrotSetBoettcher

MandelbrotSetBoettcher[z] gives the Böttcher coordinate of z with respect to the Mandelbrot set.

MandelbrotSetDistance

MandelbrotSetDistance[c] estimates the distance from c to the nearest point in the Mandelbrot set.

MandelbrotSetDistance[c,"Interior"] estimates the distance from c to the nearest point in the complement of the Mandelbrot set.

MandelbrotSetIterationCount

MandelbrotSetIterationCount[c] returns the number of iterations of the function f(z)z2+c, beginning with z0, that are needed to determine whether c is in the Mandelbrot set.

MandelbrotSetMemberQ

MandelbrotSetMemberQ[z] returns True if z is in the Mandelbrot set, and False otherwise.

MandelbrotSetPlot

MandelbrotSetPlot[{zmin,zmax}] plots the portion of the Mandelbrot set inside the rectangle with corners zmin and zmax.

MandelbrotSetPlot[] plots the Mandelbrot set over a default rectangle.

MangoldtLambda

MangoldtLambda[n] gives the von Mangoldt function Λ(n).

ManhattanDistance

ManhattanDistance[u,v] gives the Manhattan or "city block" distance between vectors u and v.

Manipulate

Manipulate[expr,{u,umin,umax}] generates a version of expr with controls added to allow interactive manipulation of the value of u. 

Manipulate[expr,{u,umin,umax,du}] allows the value of u to vary between umin and umax in steps du. 

Manipulate[expr,{{u,uinit},umin,umax,…}] takes the initial value of u to be uinit. 

Manipulate[expr,{{u,uinit,ulbl},…}] labels the controls for u with ulbl. 

Manipulate[expr,{u,{u1,u2,…}}] allows u to take on discrete values u1,u2,…. 

Manipulate[expr,{u,…},{v,…},…] provides controls to manipulate each of the u,v,…. 

Manipulate[expr,cu->{u,…},cv->{v,…},…] links the controls to the specified controllers on an external device.

MannedSpaceMissionData

MannedSpaceMissionData[entity,property] gives the value of the specified property for the manned space mission entity.

MannedSpaceMissionData[{entity1,entity2,…},property] gives a list of property values for the specified manned space mission entities.

MannedSpaceMissionData[name,property,annotation] gives the specified annotation associated with the given property.

MannWhitneyTest

MannWhitneyTest[{data1,data2}] tests whether the medians of data1 and data2 are equal.

MannWhitneyTest[dspec,μ0] tests the median difference against μ0.

MannWhitneyTest[dspec,μ0,"property"] returns the value of "property".

MantissaExponent

MantissaExponent[x] gives a list containing the mantissa and exponent of a number x. 

MantissaExponent[x,b] gives the base‐b mantissa and exponent of x. 

Manual

Manual represents an option or other value that is to be selected manually, usually by some form of interactive manipulation.

Map

Map[f,expr] or f/@expr applies f to each element on the first level in expr. 

Map[f,expr,levelspec] applies f to parts of expr specified by levelspec. 

Map[f] represents an operator form of Map that can be applied to an expression.

MapAll

MapAll[f,expr] or f//@expr applies f to every subexpression in expr. 

MapAt

MapAt[f,expr,n] applies f to the element at position n in expr. If n is negative, the position is counted from the end. 

MapAt[f,expr,{i,j,…}] applies f to the part of expr at position {i,j,…}.

MapAt[f,expr,{{i1,j1,…},{i2,j2,…},…}] applies f to parts of expr at several positions.

MapAt[f,pos] represents an operator form of MapAt that can be applied to an expression.

MapIndexed

MapIndexed[f,expr] applies f to the elements of expr, giving the part specification of each element as a second argument to f. 

MapIndexed[f,expr,levelspec] applies f to all parts of expr on levels specified by levelspec. 

MapIndexed[f] represents an operator form of MapIndexed that can be applied to an expression.

MAProcess

MAProcess[{b1,…,bq},v] represents a moving-average process of order q with normal white noise variance v.

MAProcess[{b1,…,bq},Σ] represents a vector MA process with multinormal white noise covariance matrix Σ.

MAProcess[{b1,…,bq},v,init] represents an MA process with initial data init. 

MAProcess[c,…] represents an MA process with a constant c.

MapThread

MapThread[f,{{a1,a2,…},{b1,b2,…},…}] gives {f[a1,b1,…],f[a2,b2,…],…}. 

MapThread[f,{expr1,expr2,…},n] applies f to the parts of the expri at level n.

MapThread[f] represents an operator form of MapThread that can be applied to an expression.

MarchenkoPasturDistribution

MarchenkoPasturDistribution[λ,σ] represents a Marchenko–Pastur distribution with asymptotic ratio λ and scale parameter σ.

MarchenkoPasturDistribution[λ] represents a Marchenko–Pastur distribution with unit scale parameter.

MarcumQ

MarcumQ[m,a,b] gives Marcum's Q function Qm(a,b).

MarcumQ[m,a,b0,b1] gives Marcum's Q function Qm(a,b0)-Qm(a,b1).

MardiaCombinedTest

MardiaCombinedTest[data] tests whether data follows a MultinormalDistribution using the Mardia combined test.

MardiaCombinedTest[data,"property"] returns the value of "property".

MardiaKurtosisTest

MardiaKurtosisTest[data] tests whether data follows a MultinormalDistribution using the Mardia kurtosis test.

MardiaKurtosisTest[data,"property"] returns the value of "property".

MardiaSkewnessTest

MardiaSkewnessTest[data] tests whether data follows a MultinormalDistribution using the Mardia skewness test.

MardiaSkewnessTest[data,"property"] returns the value of "property".

MarginalDistribution

MarginalDistribution[dist,k] represents a univariate marginal distribution of the kth coordinate from the multivariate distribution dist.

MarginalDistribution[dist,{k1,k2,…}] represents a multivariate marginal distribution of the {k1,k2,…} coordinates.

MarkovProcessProperties

MarkovProcessProperties[mproc] gives a summary of properties for the finite state Markov process mproc.

MarkovProcessProperties[mproc,"property"] gives the specified "property" for the process mproc.

Masking

Masking is an option for various image and signal processing functions that specifies on which regions they should operate.

MassConcentrationCondition

MassConcentrationCondition[pred,vars,pars] represents a mass concentration boundary condition for PDEs with predicate pred indicating where it applies, with model variables vars and global parameters pars.

MassConcentrationCondition[pred,vars,pars,lkey] represents a thermal surface boundary condition with local parameters specified in pars[lkey].

MassFluxValue

MassFluxValue[pred,vars,pars] represents a mass flux boundary condition for PDEs with predicate pred indicating where it applies, with model variables vars and global parameters pars.

MassFluxValue[pred,vars,pars,lkey] represents a mass flux boundary condition with local parameters specified in pars[lkey].

MassImpermeableBoundaryValue

MassImpermeableBoundaryValue[pred,vars,pars] represents a mass impermeable boundary condition for PDEs with predicate pred indicating where it applies, with model variables vars and global parameters pars.

MassImpermeableBoundaryValue[pred,vars,pars,lkey] represents a mass impermeable boundary condition with local parameters specified in pars[lkey].

MassOutflowValue

MassOutflowValue[pred,vars,pars] represents a mass outflow boundary condition for PDEs with predicate pred indicating where it applies, with model variables vars and global parameters pars.

MassOutflowValue[pred,vars,pars,lkey] represents a mass outflow boundary condition with local parameters specified in pars[lkey].

MassSymmetryValue

MassSymmetryValue[pred,vars,pars] represents a mass symmetry boundary condition for PDEs with predicate pred indicating where it applies, with model variables vars and global parameters pars.

MassSymmetryValue[pred,vars,pars,lkey] represents a mass symmetry boundary condition with local parameters specified in pars[lkey].

MassTransferValue

MassTransferValue[pred,vars,pars] represents a mass transfer boundary condition for PDEs with predicate pred indicating where it applies, with model variables vars and global parameters pars.

MassTransferValue[pred,vars,pars,lkey] represents a mass transfer boundary condition with local parameters specified in pars[lkey].

MassTransportPDEComponent

MassTransportPDEComponent[vars,pars] yields a mass transport PDE term with variables vars and parameters pars.

MatchingDissimilarity

MatchingDissimilarity[u,v] gives the matching dissimilarity between Boolean vectors u and v.

MatchLocalNameQ

MatchLocalNameQ is an internal symbol.

MatchLocalNames

MatchLocalNames is an option for Trace and related functions that specifies whether symbols such as x should match symbols with local names of the form x$nnn. 

MatchQ

MatchQ[expr,form] returns True if expr matches the pattern form, and returns False otherwise.

MatchQ[form] represents an operator form of MatchQ that can be applied to an expression.

MaterialShading

MaterialShading["material"] is a three-dimensional graphics directive specifying that surfaces that follow are to be drawn with the material "material" appearance.

MaterialShading[{"material",col}] uses the specified color col as the base color.

MaterialShading[<|parm1->val1,parm2->val2,…|>] uses the specified parameters parms.

MathematicalFunctionData

MathematicalFunctionData[entity,property] gives data corresponding to property for the mathematical function specified by entity.

MathematicalFunctionData[entprop,annotation] gives data corresponding to the given entity or property in the format specified by annotation.

MathematicalFunctionData[entity,property,annotation] gives data for the given entity-property pair in the format specified by annotation.	

MathematicalFunctionData[entity,property,{qual1->val1,qual2->val2,…}] gives data for the given entity-property pair with property qualifiers qual1, qual2, … set to the given values.

MathematicalFunctionData[entity,property,annotation,{qual1->val1,qual2->val2,…}] gives data corresponding to the given entity, property and annotation format, with property qualifiers qual1, qual2, … set to the given values.

MathieuC

MathieuC[a,q,z] gives the even Mathieu function with characteristic value a and parameter q. 

MathieuCharacteristicA

MathieuCharacteristicA[r,q] gives the characteristic value ar for even Mathieu functions with characteristic exponent r and parameter q. 

MathieuCharacteristicB

MathieuCharacteristicB[r,q] gives the characteristic value br for odd Mathieu functions with characteristic exponent r and parameter q. 

MathieuCharacteristicExponent

MathieuCharacteristicExponent[a,q] gives the characteristic exponent r for Mathieu functions with characteristic value a and parameter q. 

MathieuCPrime

MathieuCPrime[a,q,z] gives the derivative with respect to z of the even Mathieu function with characteristic value a and parameter q. 

MathieuGroupM11

MathieuGroupM11[] represents the sporadic simple Mathieu group M11.

MathieuGroupM12

MathieuGroupM12[] represents the sporadic simple Mathieu group M12.

MathieuGroupM22

MathieuGroupM22[] represents the sporadic simple Mathieu group M22.

MathieuGroupM23

MathieuGroupM23[] represents the sporadic simple Mathieu group M23.

MathieuGroupM24

MathieuGroupM24[] represents the sporadic simple Mathieu group M24.

MathieuS

MathieuS[a,q,z] gives the odd Mathieu function with characteristic value a and parameter q. 

MathieuSPrime

MathieuSPrime[a,q,z] gives the derivative with respect to z of the odd Mathieu function with characteristic value a and parameter q. 

MathMLForm

MathMLForm[expr] prints as a MathML form of expr. 

Matrices

Matrices[{d1,d2}] represents the domain of matrices of dimensions d1×d2.

Matrices[{d1,d2},dom] represents the domain of matrices of dimensions d1×d2, with components in the domain dom.

Matrices[{d1,d2},dom,sym] represents the subdomain of matrices d1×d2 with symmetry sym.

MatrixExp

MatrixExp[m] gives the matrix exponential of m. 

MatrixExp[m,v] gives the matrix exponential of m applied to the vector v.

MatrixForm

MatrixForm[list] prints with the elements of list arranged in a regular array. 

MatrixFunction

MatrixFunction[f,m] gives the matrix generated by the scalar function f at the matrix argument m.

MatrixLog

MatrixLog[m] gives the matrix logarithm of a matrix m.

MatrixNormalDistribution

MatrixNormalDistribution[Σrow,Σcol] represents zero mean matrix normal distribution with row covariance matrix Σrow and column covariance matrix Σcol.

MatrixNormalDistribution[μ,Σrow,Σcol] represents matrix normal distribution with mean matrix μ.

MatrixPlot

MatrixPlot[m] generates a plot that gives a visual representation of the values of elements in a matrix.

MatrixPower

MatrixPower[m,n] gives the nth matrix power of the matrix m. 

MatrixPower[m,n,v] gives the nth matrix power of the matrix m applied to the vector v.

MatrixPropertyDistribution

MatrixPropertyDistribution[expr,xmdist] represents the distribution of the matrix property expr where the matrix-valued random variable x follows the matrix distribution mdist.

MatrixPropertyDistribution[expr,{x1mdist1,x2mdist2,…}] represents the distribution where x1, x2, … are independent and follow the matrix distributions mdist1, mdist2, ….

MatrixQ

MatrixQ[expr] gives True if expr is a list of lists or a two-dimensional SparseArray object that can represent a matrix, and gives False otherwise. 

MatrixQ[expr,test] gives True only if test yields True when applied to each of the matrix elements in expr. 

MatrixRank

MatrixRank[m] gives the rank of the matrix m. 

MatrixTDistribution

MatrixTDistribution[Σrow,Σcol,ν] represents zero mean matrix t distribution with row covariance matrix Σrow, column covariance matrix Σcol, and degrees of freedom parameter ν.

MatrixTDistribution[μ,Σrow,Σcol,ν] represents matrix t distribution with mean matrix μ.

Max

Max[x1,x2,…] yields the numerically largest of the xi. 

Max[{x1,x2,…},{y1,…},…] yields the largest element of any of the lists. 

MaxCellMeasure

MaxCellMeasure is an option for DiscretizeRegion and related functions that specifies the maximum cell measure for the result.

MaxColorDistance

MaxColorDistance is an option to specify the maximum distance allowed between colors.

MaxDate

MaxDate[{date1,date2,…}] gives the latest date of the datei.

MaxDate[interval] gives the endpoint of the date interval interval.

MaxDate[interval,gran] gives the endpoint of interval as specified by granularity gran.

MaxDetect

MaxDetect[image] gives a binary image in which white pixels correspond to constant extended maxima in image.

MaxDetect[image,h] finds extended maxima where the range of values is not greater than h.

MaxDetect[data,…] applies maxima detection to an array of data.

MaxDuration

MaxDuration is an option that specifies the maximum duration for audio playback or capture.

MaxExtraBandwidths

MaxExtraBandwidths is an option to SmoothKernelDistribution that controls the behavior outside that data range.

MaxExtraConditions

MaxExtraConditions is an option to Solve and related functions that specifies how many extra equational conditions on continuous parameters to allow in solutions that are given.

MaxFeatureDisplacement

MaxFeatureDisplacement is an option that specifies the maximum displacement allowed for any feature.

MaxFeatures

MaxFeatures is an option that specifies the maximum number of features that will be returned from feature detection algorithms.

MaximalBy

MaximalBy[data,f] returns a list of the elements ei of data for which the value of f[ei] is maximal.

MaximalBy[data,f,n] returns a list of the elements ei of data corresponding to the n largest f[ei].

MaximalBy[data,f,n,p] uses the ordering function p for sorting.

MaximalBy[f] represents an operator form of MaximalBy that can be applied to an expression.

Maximize

Maximize[f,x] maximizes f symbolically with respect to x.

Maximize[f,{x,y,…}] maximizes f symbolically with respect to x, y, …. 

Maximize[{f,cons},{x,y,…}] maximizes f symbolically subject to the constraints cons. 

Maximize[…,x∈rdom] constrains x to be in the region or domain rdom.

Maximize[…,…,dom] constrains variables to the domain dom, typically Reals or Integers.

MaxItems

MaxItems is an option that specifies the maximum number of items to be used or shown.

MaxIterations

MaxIterations is an option that specifies the maximum number of iterations that should be tried in various built-in functions and algorithms.

MaxLimit

MaxLimit[f,x->x*] gives the max limit x->x*f(x). 

MaxLimit[f,{x1->x1*,…,xn->xn*}] gives the nested max limit +x1->x1*⋯ +xn->xn*f(x1,…,xn). 

MaxLimit[f,{x1,…,xn}->{x1*,…,xn*}] gives the multivariate max limit +{x1,…,xn}->{x1*,…,xn*}f(x1,…,xn).

MaxMemoryUsed

MaxMemoryUsed[] gives the maximum number of bytes used to store all data for the current Wolfram System session.

MaxMemoryUsed[expr] gives the maximum number of bytes used during the evaluation of expr.

MaxMixtureKernels

MaxMixtureKernels is an option for SmoothKernelDistribution and related functions that specifies the maximum number and location of kernel functions to use in the estimation.

MaxOverlapFraction

MaxOverlapFraction is an option that specifies the maximum acceptable overlap between different identifications.

MaxPlotPoints

MaxPlotPoints is an option for plotting functions like ArrayPlot and ListPlot3D that specifies the maximum number of points that will explicitly be included in the output. 

MaxPoints

MaxPoints is an option for NIntegrate specifying the maximum total number of times to sample the integrand.

MaxRecursion

MaxRecursion is an option for functions like NIntegrate and Plot that specifies how many recursive subdivisions can be made. 

MaxStableDistribution

MaxStableDistribution[μ,σ,ξ] represents a generalized maximum extreme value distribution with location parameter μ, scale parameter σ, and shape parameter ξ.

MaxStepFraction

MaxStepFraction is an option to functions like NDSolve that specifies the maximum fraction of the total range to cover in a single step.

MaxSteps

MaxSteps is an option to functions like NDSolve that specifies the maximum number of steps to take in generating a result.

MaxStepSize

MaxStepSize is an option to functions like NDSolve that specifies the maximum size of a single step used in generating a result.

MaxTrainingRounds

MaxTrainingRounds is an option for NetTrain and related functions that specifies the maximum number of rounds of training to do.

MaxValue

MaxValue[f,x] gives the maximum value of f with respect to x.

MaxValue[f,{x,y,…}] gives the maximum value of f with respect to x, y, …. 

MaxValue[{f,cons},{x,y,…}] gives the maximum value of f subject to the constraints cons. 

MaxValue[…,x∈rdom] constrains x to be in the region or domain rdom.

MaxValue[…,…,dom] constrains variables to the domain dom, typically Reals or Integers.

MaxwellDistribution

MaxwellDistribution[σ] represents a Maxwell distribution with scale parameter σ.

MaxWordGap

MaxWordGap is an option for SearchAdjustment that specifies the number of words that can occur between the terms of a phrase.

McLaughlinGroupMcL

McLaughlinGroupMcL[] represents the sporadic simple McLaughlin group McL.

Mean

Mean[data] gives the mean estimate of the elements in data. 

Mean[dist] gives the mean of the distribution dist.

MeanAbsoluteLossLayer

MeanAbsoluteLossLayer[] represents a loss layer that computes the mean absolute loss between the "Input" port and "Target" port.

MeanAround

MeanAround[{x1,x2,x3,…}] gives an Around object describing the mean of the xi and its uncertainty.

MeanAround[{{x11,x12,…},{x21,…},…}] gives a VectorAround object describing the means of the vectors xi and their covariance. 

MeanClusteringCoefficient

MeanClusteringCoefficient[g] gives the mean clustering coefficient of the graph g.

MeanClusteringCoefficient[{v->w,…}] uses rules v->w to specify the graph g.

MeanDegreeConnectivity

MeanDegreeConnectivity[g] gives a list of k-mean degree connectivity for the graph g for successive k=0,1,2… .

MeanDegreeConnectivity[g,"In"] gives a list of k-mean in-degree connectivity for the graph g.

MeanDegreeConnectivity[g,"Out"] gives a list of k-mean out-degree connectivity for the graph g.

MeanDegreeConnectivity[{v->w,…},…] uses rules v->w to specify the graph g.

MeanDeviation

MeanDeviation[data] gives the mean absolute deviation from the mean of the elements in data.

MeanGraphDistance

MeanGraphDistance[g] gives the mean distance between all pairs of vertices in the graph g.

MeanGraphDistance[{v->w,…}] uses rules v->w to specify the graph g.

MeanNeighborDegree

MeanNeighborDegree[g] gives a list of mean neighbor degrees of vertices for the graph g.

MeanNeighborDegree[g,"In"] gives a list of mean neighbor in-degrees.

MeanNeighborDegree[g,"Out"] gives a list of mean neighbor out-degrees.

MeanNeighborDegree[{v->w,…},…] uses rules v->w to specify the graph g.

MeanPointDensity

MeanPointDensity[pdata] estimates the mean point density λ from point data pdata in the observation region reg. 

MeanPointDensity[bdata] estimates the mean point density λ from binned data bdata.

MeanPointDensity[pproc] computes the mean point density λ for point process pproc.

MeanShift

MeanShift[list,d] replaces each element in list by the mean of the values of all elements that differ by less than d.

MeanShift[list,d,{p1,p2,…}] returns the list where only the specified parts pi are replaced with mean-shifted values.

MeanShift[image,…] mean shift of the pixel values in image.

MeanSquaredLossLayer

MeanSquaredLossLayer[] represents a loss layer that computes the mean squared loss between its "Input" port and "Target" port.

Median

Median[data] gives the median estimate q&^1/4 of the elements in data. 

Median[dist] gives the median of the distribution dist. 

MedianDeviation

MedianDeviation[data] gives the median absolute deviation from the median q&^1/2 of the elements in data.

MedicalTestData

MedicalTestData[entity,property] gives the value of the specified property for the medical test entity.

MedicalTestData[{entity1,entity2,…},property] gives a list of property values for the specified medical test entities.

MedicalTestData[entity,property,annotation] gives the specified annotation associated with the given property.

Medium

Medium is a style or option setting that specifies that objects should be medium sized.

MeijerGReduce

MeijerGReduce[expr,x] attempts to reduce expr to a single MeijerG object as a function of x.

MeixnerDistribution

MeixnerDistribution[a,b,m,d] represents a Meixner distribution with location parameter m, scale parameter a, skew parameter b, and shape parameter d.

MellinConvolve

MellinConvolve[f,g,x,y] gives the Mellin convolution with respect to x of the expressions f and g.

MellinConvolve[f,g,{x1,x2,…},{y1,y2,…}] gives the multidimensional Mellin convolution.

MellinTransform

MellinTransform[expr,x,s] gives the Mellin transform of expr.

MellinTransform[expr,{x1,x2,…},{s1,s2,…}] gives the multidimensional Mellin transform of expr. 

MemberQ

MemberQ[list,form] returns True if an element of list matches form, and False otherwise. 

MemberQ[list,form,levelspec] tests all parts of list specified by levelspec. 

MemberQ[form] represents an operator form of MemberQ that can be applied to an expression.

MemoryAvailable

MemoryAvailable[] gives the estimated number of bytes readily available for storing additional data in the current Wolfram Language kernel session.

MemoryConstrained

MemoryConstrained[expr,b] evaluates expr, stopping if more than b bytes of memory are requested. 

MemoryConstrained[expr,b,failexpr] returns failexpr if the memory constraint is not met. 

MemoryConstraint

MemoryConstraint is an option for TestReport and VerificationTest that specifies how much memory (in bytes) the test is allowed to use.

MemoryInUse

MemoryInUse[] gives the number of bytes currently being used to store all data in the current Wolfram Language kernel session. 

MemoryInUse[$FrontEnd] gives the number of bytes used in the Wolfram System front end.

MengerMesh

MengerMesh[n] gives a mesh region representing the nth-step Menger sponge. 

MengerMesh[n,d] gives the nth-step Menger sponge in dimension d.

Merge

Merge[{assoc1,assoc2,…},f] merges the associations associ, using the function f to combine values with the same key. 

Merge[{key1->val1,key2->val2,…},f] gives an association in which values corresponding to identical keys are combined using f. 

Merge[f] represents an operator form of Merge that can be applied to an expression.

MergingFunction

MergingFunction is an option for functions such as PersistentSymbol that specifies a function to apply to the list of values found.

MersennePrimeExponent

MersennePrimeExponent[n] gives the nth Mersenne prime exponent.

MersennePrimeExponentQ

MersennePrimeExponentQ[n] returns True if n is a Mersenne prime exponent, and False otherwise.

Mesh

Mesh is an option for Plot3D, DensityPlot, and other plotting functions that specifies what mesh should be drawn. 

MeshCellCentroid

MeshCellCentroid is an annotation of MeshRegion and BoundaryMeshRegion objects that gives the centroids of mesh cells.

MeshCellHighlight

MeshCellHighlight is an option and annotation of MeshRegion, BoundaryMeshRegion, and related functions that specifies mesh cells to highlight.

MeshCellLabel

MeshCellLabel is an option to MeshRegion, BoundaryMeshRegion and related functions that specifies labels and placements for mesh cells. 

MeshCellMarker

MeshCellMarker is an option to MeshRegion and BoundaryMeshRegion that specifies integer markers to associate with mesh cells. 

MeshCellMeasure

MeshCellMeasure is an annotation of MeshRegion and BoundaryMeshRegion objects that gives the measures of mesh cells.

MeshCellQuality

MeshCellQuality is an annotation of MeshRegion and BoundaryMeshRegion objects that gives a quality measure for mesh cells.

MeshCellShapeFunction

MeshCellShapeFunction is an option and annotation for MeshRegion, BoundaryMeshRegion, and related functions that specifies functions to use to generate primitives for rendering mesh cells.

MeshCellStyle

MeshCellStyle is an option and annotation of MeshRegion, BoundaryMeshRegion, and related functions that specifies styles to use for mesh cells. 

MeshConnectivityGraph

MeshConnectivityGraph[mr,0] gives a graph of points connected by lines.

MeshConnectivityGraph[mr,d] gives a graph between cells of dimension d that share a cell of dimension d-1.

MeshConnectivityGraph[mr,{d,e},r] gives a graph from cells of dimension d to cells of dimension e that share a cell of dimension r.

MeshCoordinates

MeshCoordinates[mreg] gives a list of coordinates in the mesh region mreg.

MeshFunctions

MeshFunctions is an option for plotting functions that specifies functions to use to determine the placement of mesh divisions. 

MeshRefinementFunction

MeshRefinementFunction is an option for DiscretizeRegion and related functions that specifies a function to indicate whether mesh cells should be refined or not.

MeshRegionQ

MeshRegionQ[reg] yields True if the region reg is a valid MeshRegion object and False otherwise.

MeshShading

MeshShading is an option for plotting functions that gives lists of colors to use for regions between mesh divisions. 

MeshStyle

MeshStyle is an option for Plot3D, DensityPlot, and other plotting functions that specifies the style in which to draw a mesh. 

Message

Message[symbol::tag] prints the message symbol::tag unless it has been switched off. 

Message[symbol::tag,e1,e2,…] prints a message, inserting the values of the ei as needed. 

MessageDialog

MessageDialog[expr] puts up a standard message dialog that displays expr together with an OK button.

MessageDialog[expr,{lbl1:>act1,lbl2:>act2,…}] includes buttons with labels lbli that evaluate the corresponding acti if clicked.

MessageName

symbol::tag is a name for a message. 

MessagePacket

MessagePacket[symbol,string] is a WSTP packet containing a Wolfram Language message identifier of the form symbol::string.

Messages

Messages[symbol] gives all the messages assigned to a particular symbol. 

MetaCharacters

MetaCharacters is an option to StringPosition. With MetaCharacters -> None, no strings have special meanings. MetaCharacters -> {c1, c2, c3} specifies the metacharacters for pattern escape, single character matching and multiple character matching. MetaCharacters -> Automatic is equivalent to MetaCharacters -> {"\\", ".", "*"}.

MetaInformation

MetaInformation is an option giving metainformation for Image, CloudObject, and other objects.

MeteorShowerData

MeteorShowerData[entity,property] gives the value of the specified property for the meteor shower entity.

MeteorShowerData[{entity1,entity2,…},property] gives a list of property values for the specified meteor shower entities.

MeteorShowerData[name,property,annotation] gives the specified annotation associated with the given property.

Method

Method is an option for various algorithm-intensive functions that specifies what internal methods they should use.

MexicanHatWavelet

MexicanHatWavelet[] represents the Mexican hat wavelet of width 1.

MexicanHatWavelet[σ] represents the Mexican hat wavelet of width σ.

MeyerWavelet

MeyerWavelet[] represents the Meyer wavelet of order 3.

MeyerWavelet[n] represents the Meyer wavelet of order n evaluated on the equally spaced interval {-10,10}.

MeyerWavelet[n,lim] represents the Meyer wavelet of order n evaluated on the equally spaced interval {-lim,lim}. 

Midpoint

Midpoint[{p1,p2}] gives the midpoint of the line segment connecting the points p1 and p2.

Midpoint[Line[{p1,p2}]] gives the midpoint of a line.

MIMETypeToFormatList

MIMETypeToFormatList[] returns lists of file formats corresponding to all registered MIME types.

MIMETypeToFormatList[mime] returns a list of file formats that matches the MIME type mime.

Min

Min[x1,x2,…] yields the numerically smallest of the xi. 

Min[{x1,x2,…},{y1,…},…] yields the smallest element of any of the lists. 

MinColorDistance

MinColorDistance is an option for DominantColors that specifies the minimum distance between returned colors.

MinDate

MinDate[{date1,date2,…}] gives the earliest date of the datei.

MinDate[interval] gives the beginning of the date interval interval.

MinDate[interval,gran] gives the beginning of interval as specified by granularity gran.

MinDetect

MinDetect[image] gives a binary image in which white pixels correspond to constant extended minima in image.

MinDetect[image,h] finds extended minima where the range of values is not greater than h.

MinDetect[data,…] applies minima detection to an array of data.

MineralData

MineralData[entity,property] gives the value of the specified property for the mineral entity.

MineralData[{entity1,entity2,…},property] gives a list of property values for the specified mineral entities.

MineralData[entity,property,annotation] gives the specified annotation associated with the given property.

MinimalBy

MinimalBy[data,f] returns a list of the elements ei of data for which the value of f is minimal.

MinimalBy[data,f,n] returns a list of the elements ei of data corresponding to the n smallest f[ei].

MinimalBy[data,f,n,p] uses the ordering function p for sorting.

MinimalBy[f] represents an operator form of MinimalBy that can be applied to an expression.

MinimalPolynomial

MinimalPolynomial[s,x] gives the minimal polynomial in x for which the algebraic number s is a root. 

MinimalPolynomial[u,x] gives the minimal polynomial of the finite field element u over p.

MinimalPolynomial[u,x,k] gives the minimal polynomial of u over the pk-element subfield of the ambient field of u.

MinimalPolynomial[u,x,emb] gives the minimal polynomial of u relative to the finite field embedding emb.

MinimalStateSpaceModel

MinimalStateSpaceModel[sys] gives the minimal state-space model of the state-space model sys.

MinimalStateSpaceModel[sys,{z1,…}] specifies the new coordinates zi.

Minimize

Minimize[f,x] minimizes f symbolically with respect to x.

Minimize[f,{x,y,…}] minimizes f symbolically with respect to x, y, …. 

Minimize[{f,cons},{x,y,…}] minimizes f symbolically subject to the constraints cons. 

Minimize[…,x∈rdom] constrains x to be in the region or domain rdom.

Minimize[…,…,dom] constrains variables to the domain dom, typically Reals or Integers.

MinimumTimeIncrement

MinimumTimeIncrement[tseries] gives the minimum time increment in the time series tseries.

MinIntervalSize

MinIntervalSize is an option for IntervalSlider that specifies the minimum size of the interval during interactive editing.

MinkowskiQuestionMark

MinkowskiQuestionMark[x] gives Minkowski's question mark function ?(x).

MinLimit

MinLimit[f,x->x*] gives the min limit x->x*f(x). 

MinLimit[f,{x1->x1*,…,xn->xn*}] gives the nested min limit +x1->x1*⋯ +xn->xn*f(x1,…,xn). 

MinLimit[f,{x1,…,xn}->{x1*,…,xn*}] gives the multivariate min limit +{x1,…,xn}->{x1*,…,xn*}f(x1,…,xn).

MinMax

MinMax[list] gives the list {Min[list],Max[list]}.

MinMax[list,δ] gives {Min[list]-δ, Max[list]+δ}.

MinMax[list,Scaled[s]] gives {Min[list]-δ, Max[list]+δ} where δ=s×(Max[list]-Min[list]).

MinMax[list,{δmin,δmax}] gives {Min[list]-δmin,Max[list]+δmax}.

MinorPlanetData

MinorPlanetData[entity,property] gives the value of the specified property for the minor planet entity.

MinorPlanetData[{entity1,entity2,…},property] gives a list of property values for the specified minor planet entities.

MinorPlanetData[entity,property,annotation] gives the specified annotation associated with the given property.

Minors

Minors[m] gives the minors of a matrix m. 

Minors[m,k] gives the kth minors.

Minors[m,k,f] applies the function f rather than Det to each of the submatrices picked out. 

MinPointSeparation

MinPointSeparation is an option for GeoGraphValuePlot that determines when to merge nearby vertices into a single vertex.

MinRecursion

MinRecursion is an option for NIntegrate and other numerical functions that use a recursive algorithm. With MinRecursion -> n, a minimum depth of recursion of n is used before tests for convergence begin.

MinStableDistribution

MinStableDistribution[μ,σ,ξ] represents a generalized minimum extreme value distribution with location parameter μ, scale parameter σ, and shape parameter ξ.

Minus

-x is the arithmetic negation of x. 

MinusPlus

MinusPlus[x] displays as ∓x.

MinusPlus[x,y,…] displays as x∓y∓….

MinValue

MinValue[f,x] gives the minimum value of f with respect to x.

MinValue[f,{x,y,…}] gives the exact minimum value of f with respect to x, y, …. 

MinValue[{f,cons},{x,y,…}] gives the minimum value of f subject to the constraints cons. 

MinValue[…,x∈rdom] constrains x to be in the region or domain rdom.

MinValue[…,…,dom] constrains variables to the domain dom, typically Reals or Integers.

Missing

Missing[] represents data that is missing.

Missing["reason"] specifies a reason for the data's being missing.

Missing["reason",expr] associates the expression expr with the missing data. 

MissingBehavior

MissingBehavior is an option to Query and related functions that specifies how expressions with head Missing should be interpreted in the context of other functions.

MissingDataMethod

MissingDataMethod is an option to TemporalData and other functions that controls how to process missing data. 

MissingDataRules

MissingDataRules is an option for SemanticImport and related functions that specifies what should be considered "missing" and what to replace it with.

MissingQ

MissingQ[expr] gives True if expr has head Missing.

MissingString

MissingString is an option for TextString and related functions that indicates how an expression with head Missing should be converted to a string.

MissingStyle

MissingStyle is an option for GeoRegionValuePlot that specifies how locations with missing data should be displayed.

MissingValuePattern

MissingValuePattern is an option for SynthesizeMissingValues and ToTabular to specify which data elements are considered missing.

MissingValueSynthesis

MissingValueSynthesis is an option for functions such as Classify that specifies how missing values should be replaced.

MittagLefflerE

MittagLefflerE[α,z] gives the Mittag–Leffler function Eα(z).

MittagLefflerE[α,β,z] gives the generalized Mittag–Leffler function Eα,β(z).

MixedFractionParts

MixedFractionParts[expr] gives the list {IntegerPart[expr],FractionalPart[expr]}.

MixedGraphQ

MixedGraphQ[g] yields True if the graph g is a mixed graph and False otherwise. 

MixedMagnitude

MixedMagnitude[{val1,val2,…,valn}] represents a mixed-magnitude expression consisting of values val1 through valn.

MixedRadix

MixedRadix[{b1,…,bn}] represents the list of bases of a numerical system in which different digits have different bases.

MixedRadixQuantity

MixedRadixQuantity[{value1,…,valuen},{unit1,…,unitn}] yields a single Quantity expression representing the addition of compatible units with magnitude values.

MixedUnit

MixedUnit[{unit1,unit2,…,unitn}] represents a mixed-unit expression consisting of units unit1 through unitn.

MixtureDistribution

MixtureDistribution[{w1,…,wn},{dist1,…,distn}] represents a mixture distribution whose CDF is given as a sum of the CDFs of the component distributions disti, each with weight wi.

Mod

Mod[m,n] gives the remainder on division of m by n. 

Mod[m,n,d] uses an offset d. 

Modal

Modal is an option to functions such as CreateDialog that specifies whether the dialog that is created should be modal to the Wolfram System front end.

Mode

Mode is an option to Eliminate and related functions that specifies in what sense the equations are to be solved. The possible settings for Mode are Generic, Modular, and Rational.

Modular

Modular is a setting for the option Mode in Solve and related functions, which specifies that equations need be satisfied only modulo an integer.

ModularInverse

ModularInverse[k,n] gives the modular inverse of k modulo n.

ModularLambda

ModularLambda[τ] gives the modular lambda elliptic function λ(τ). 

Module

Module[{x,y,…},expr] specifies that occurrences of the symbols x, y, … in expr should be treated as local. 

Module[{x=x0,…},expr] defines initial values for x, …. 

Modulus

Modulus->n is an option that can be given in certain algebraic functions to specify that integers should be treated modulo n. 

MoebiusMu

MoebiusMu[n] gives the Möbius function μ(n). 

MoleculeDraw

MoleculeDraw[] displays a window with interactive tools for drawing a Molecule, and returns the result.

MoleculeDraw[mol] displays a window that initially contains the Molecule mol.

MoleculeMatchQ

MoleculeMatchQ[mol,patt] returns True if the Molecule matches the given pattern.

MoleculeMatchQ[patt] represents an operator form of MoleculeMatchQ that can be applied to a molecule.

MoleculeProperty

MoleculeProperty[pname] represents a property identified by pname for use in MoleculeValue.

MoleculeProperty[{pname,item}] represents a property that applies to item within a molecule.

MoleculeQ

MoleculeQ[mol] returns True if mol is a valid Molecule expression, and False otherwise.

MoleculeSubstructureCount

MoleculeSubstructureCount[mol,patt] gives a count of the number of times patt appears as a substructure in mol.

MoleculeSubstructureCount[patt] represents an operator form of MoleculeSubstructureCount that can be applied to a molecule.

Moment

Moment[data,r] gives the order r moment μ r of data.

Moment[data,{r1,…,rm}] gives the order {r1,…,rm} multivariate moment μ r1, …, rm of data.

Moment[dist,…] gives the moment of the distribution dist.

Moment[r] represents the order r formal moment. 

MomentConvert

MomentConvert[mexpr,form] converts the moment expression mexpr to the specified form. 

MomentEvaluate

MomentEvaluate[mexpr,dist] evaluates formal moments in the moment expression mexpr on the distribution dist.

MomentEvaluate[mexpr,list] evaluates formal moments and formal sample moments in mexpr on the data list. 

MomentEvaluate[mexpr,dist,list] evaluates formal moments on the distribution dist and formal sample moments on the data list. 

MomentGeneratingFunction

MomentGeneratingFunction[dist,t] gives the moment-generating function for the distribution dist as a function of the variable t. 

MomentGeneratingFunction[dist,{t1,t2,…}] gives the moment-generating function for the multivariate distribution dist as a function of the variables t1, t2, … . 

MomentOfInertia

MomentOfInertia[reg,pt,v] computes the moment of inertia for the region reg rotating around an axis through the point pt in direction v.

MomentOfInertia[reg] computes the moment of inertia matrix for the region reg relative to the center of mass.

MomentOfInertia[reg,pt] computes the moment of inertia matrix relative to the point pt.

Monday

Monday is a day of the week.

MonomialList

MonomialList[poly] gives the list of all monomials in the polynomial poly.

MonomialList[poly,{x1,x2,…}] gives the list of monomials with respect to the variables xi in poly.

MonomialList[poly,{x1,x2,…},order] puts the monomials in the specified order.

MonsterGroupM

MonsterGroupM[] represents the sporadic simple monster group M.

MoonPhase

MoonPhase[] gives moon phase fraction of illumination for the current date.

MoonPhase[datespec] gives moon phase fraction of illumination for the specified date.

MoonPhase[property] gives the property of the moon phase for the current date.

MoonPhase[datespec,property] gives the property of the moon phase for the specified date.

MoonPosition

MoonPosition[] gives the position of the Moon for the current date and location.

MoonPosition[datespec] gives the position of the Moon for the specified date.

MoonPosition[locationspec] gives the position of the Moon for the specified location.

MoonPosition[locationspec,datespec] gives the position of the Moon for the specified date and location.

MoonPosition[{{location1,date1},{location2,date2},…}] gives the positions of the Moon for all specified locations on the specified dates.

MoonPosition[locationspec,datespec,func] uses func to determine what to return for extended locations.

MorletWavelet

MorletWavelet[] represents a Morlet wavelet. 

MorphologicalBinarize

MorphologicalBinarize[image,{t1,t2}] creates a binary image from image by replacing all values above the upper threshold t2 with 1, also including pixels with intensities above the lower threshold t1 that are connected to the foreground.

MorphologicalBinarize[image,t] uses t as the upper threshold, automatically choosing a suitable value for the lower threshold.

MorphologicalBinarize[image] chooses the lower and the upper threshold automatically.

MorphologicalBranchPoints

MorphologicalBranchPoints[image] gives a version of a binary image image in which white pixels represent the morphological branch points.

MorphologicalComponents

MorphologicalComponents[image] gives an array in which each pixel of image is replaced by an integer index representing the connected foreground image component in which the pixel lies.

MorphologicalComponents[image,t] treats values above t as foreground.

MorphologicalComponents[video,…] computes connected components in frames of video.

MorphologicalEulerNumber

MorphologicalEulerNumber[image] computes the morphological Euler number of regions in a binary image.

MorphologicalEulerNumber[image,t] treats values above t as foreground.

MorphologicalGraph

MorphologicalGraph[image] gives a graph object that represents the connectivity of the morphological branch points and endpoints of the objects in image after applying morphological thinning.

MorphologicalPerimeter

MorphologicalPerimeter[image] picks out the morphological perimeter of regions of foreground in image.

MorphologicalPerimeter[image,t] treats values above t as foreground.

MorphologicalTransform

MorphologicalTransform[image,f] applies the function f to the 3×3 neighborhood of each pixel in a binary image image.

MorphologicalTransform[image,rule] applies a morphological transformation specified by a rule number rule.

MorphologicalTransform[image,"name"] uses a named transformation "name".

MorphologicalTransform[image,transformation,n] applies n iterations of transformation on image.

MortalityData

MortalityData[spec] gives the values of all properties for the specified demographic.

MortalityData[spec,property] gives the value of the specified property for the specified demographic.

Most

Most[expr] gives expr with the last element removed. 

MountainData

MountainData[entity,property] gives the value of the specified property for the mountain entity.

MountainData[{entity1,entity2,…},property] gives a list of property values for the specified mountain entities.

MountainData[entity,property,annotation] gives the specified annotation associated with the given property.

MovieData

MovieData[entity,property] gives the value of the specified property for the movie entity.

MovieData[{entity1,entity2,…},property] gives a list of property values for the specified movie entities.

MovieData[entity,property,annotation] gives the specified annotation associated with the given property.

MovingAverage

MovingAverage[list,r] gives the moving average of list, computed by averaging runs of r elements.

MovingAverage[list,{w1,w2,…,wr}] gives the moving average of list, computed with weights wi.

MovingMap

MovingMap[f,data,w] applies f to size w windows in the specified data.

MovingMap[f,data,wspec] uses windows specified by wspec.

MovingMap[f,data,wspec,padding] pads data using padding.

MovingMedian

MovingMedian[list,r] gives the moving median of list, computed using spans of r elements.

MoyalDistribution

MoyalDistribution[μ,σ] represents a Moyal distribution with location parameter μ and scale parameter σ.

MoyalDistribution[] represents a Moyal distribution with location parameter 0 and scale parameter 1.

MultiaxisArrangement

MultiaxisArrangement is an option to plotting functions that specifies how multiple axes are arranged.

Multicolumn

Multicolumn[list,cols] is an object that formats with the elements of list arranged in a grid with the indicated number of columns.

Multicolumn[list,{rows,Automatic}] formats as a grid with the indicated number of rows.

Multicolumn[list,{rows,cols}] formats as a grid with the indicated number of rows and columns.

Multicolumn[list] formats with the elements of list in a roughly square arrangement.

MultiedgeStyle

MultiedgeStyle is an option for GraphPlot and related functions that specifies how to draw multiple edges.

MultigraphQ

MultigraphQ[g] yields True if the graph g is a multigraph and False otherwise.

MultilaunchWarning

MultilaunchWarning is a global option that specifies whether a warning is given when you try to modify user preferences while running two copies of the Wolfram System simultaneously.

Multinomial

Multinomial[n1,n2,…] gives the multinomial coefficient (n1+n2+…)!/(n1! n2! …). 

MultinomialDistribution

MultinomialDistribution[n,{p1,p2,…,pm}] represents a multinomial distribution with n trials and probabilities pi.

MultinormalDistribution

MultinormalDistribution[Σ] represents a multivariate normal distribution with zero mean and covariance matrix Σ.

MultinormalDistribution[μ,Σ] represents a multivariate normal (Gaussian) distribution with mean vector μ and covariance matrix Σ.

Multiplicity

Multiplicity is an option to Roots. Multiplicity -> n specifies that the multiplicity of each of the roots is n in the final result.

MultiplySides

MultiplySides[rel,x] multiplies each side of the equation or inequality rel by x.

MultiplySides[rel1,rel2] multiplies the corresponding sides of two equations or inequalities.

Multiselection

Multiselection is an option to ListPicker that specifies whether multiple values may be selected.

MultivariateHypergeometricDistribution

MultivariateHypergeometricDistribution[n,{m1,m2,…,mk}] represents a multivariate hypergeometric distribution with n draws without replacement from a collection containing mi objects of type i. 

MultivariatePoissonDistribution

MultivariatePoissonDistribution[μ0,{μ1,μ2,…}] represents a multivariate Poisson distribution with mean vector {μ0+μ1,μ0+μ2,…}.

MultivariateTDistribution

MultivariateTDistribution[Σ,ν] represents the multivariate Student t distribution with scale matrix Σ and degrees of freedom parameter ν.

MultivariateTDistribution[μ,Σ,ν] represents the multivariate Student t distribution with location μ, scale matrix Σ, and ν degrees of freedom.

N

N[expr] gives the numerical value of expr. 

N[expr,n] attempts to give a result with n‐digit precision. 

NakagamiDistribution

NakagamiDistribution[μ,ω] represents a Nakagami distribution with shape parameter μ and spread parameter ω.

NameQ

NameQ["string"] yields True if there are any symbols whose names match the string pattern given, and yields False otherwise. 

Names

Names["string"] gives a list of the names of symbols that match the string. 

Names[patt] gives a list of names matching the arbitrary string pattern patt.

Names[{patt1,patt2,…}] gives a list of names matching any of the patti.

Nand

Nand[e1,e2,…] is the logical NAND function. It evaluates its arguments in order, giving True immediately if any of them are False, and False if they are all True. 

NArgMax

NArgMax[f,x] gives a position xmax at which f is numerically globally maximized.

NArgMax[f,{x,y,…}] gives a position {xmax,ymax,…} at which f is numerically globally maximized.

NArgMax[{f,cons},{x,y,…}] gives a position at which f is numerically globally maximized subject to the constraints cons. 

NArgMax[…,x∈reg] constrains x to be in the region reg.

NArgMin

NArgMin[f,x] gives a position xmin at which f is numerically globally minimized.

NArgMin[f,{x,y,…}] gives a position {xmin,ymin,…} at which f is numerically globally minimized.

NArgMin[{f,cons},{x,y,…}] gives a position at which f is numerically globally minimized subject to the constraints cons. 

NArgMin[…,x∈reg] constrains x to be in the region reg.

NBernoulliB

NBernoulliB[n] gives the numerical value of the nth Bernoulli number. 

NBernoulliB[n, d] gives the result to d-digit precision.

NBodySimulation

NBodySimulation[law,{state1,…,staten},t] generates a simulation of the motion of a system of n bodies with initial states statei, governed by the specified potential or force law, over a length of time t.

NBodySimulation[law,<|body1->state1,…,bodyn->staten|>,t] generates a simulation of the motion of a system of n bodies with names bodyi.

NBodySimulationData

NBodySimulationData[�] represents the result of an n-body simulation.

NCache

NCache[x,xn] represents a numeric cache object for a quantity with exact value x and approximate numerical value xn.

NDEigensystem

NDEigensystem[ℒ[u[x,y,…]],u,{x,y,…}∈Ω,n] gives the n smallest magnitude eigenvalues and eigenfunctions for the linear differential operator ℒ over the region Ω.

NDEigensystem[{ℒ1[u[x,y,…],v[x,y,…],…],ℒ2[u[x,y,…],v[x,y,…],…],…},{u,v,…},{x,y,…}∈Ω,n]  gives eigenvalues and eigenfunctions for the coupled differential operators {op1,op2,…} over the region Ω.

NDEigensystem[eqns,{u,…},t,{x,y,…}∈Ω,n] gives the eigenvalues and eigenfunctions in the spatial variables {x,y,…} for solutions u,… of the coupled time-dependent differential equations eqns.

NDEigenvalues

NDEigenvalues[ℒ[u[x,y,…]],u,{x,y,…}∈Ω,n] gives the n smallest magnitude eigenvalues for the linear differential operator ℒ over the region Ω.

NDEigenvalues[{ℒ1[u[x,y,…],v[x,y,…],…],ℒ2[u[x,y,…],v[x,y,…],…],…},{u,v,…},{x,y,…}∈Ω,n]  gives eigenvalues for the coupled differential operators {op1,op2,…} over the region Ω.

NDEigenvalues[eqns,{u,…},t,{x,y,…}∈Ω,n] gives the eigenvalues in the spatial variables {x,y,…} for solutions u,… of the coupled time-dependent differential equations eqns.

NDSolve

NDSolve[eqns,u,{x,xmin,xmax}] finds a numerical solution to the ordinary differential equations eqns for the function u with the independent variable x in the range xmin to xmax. 

NDSolve[eqns,u,{x,xmin,xmax},{y,ymin,ymax}] solves the partial differential equations eqns over a rectangular region.

NDSolve[eqns,u,{x,y}∈Ω] solves the partial differential equations eqns over the region Ω.

NDSolve[eqns,u,{t,tmin,tmax},{x,y}∈Ω] solves the time-dependent partial differential equations eqns over the region Ω.

NDSolve[eqns,{u1,u2,…},…] solves for the functions ui. 

NDSolveValue

NDSolveValue[eqns,expr,{x,xmin,xmax}] gives the value of expr with functions determined by a numerical solution to the ordinary differential equations eqns with the independent variable x in the range xmin to xmax. 

NDSolveValue[eqns,expr,{x,xmin,xmax},{y,ymin,ymax}] solves the partial differential equations eqns over a rectangular region.

NDSolveValue[eqns,expr,{x,y}∈Ω] solves the partial differential equations eqns over the region Ω.

NDSolveValue[eqns,u,{t,tmin,tmax},{x,y}∈Ω] solves the time-dependent partial differential equations eqns over the region Ω.

Nearest

Nearest[{elem1,elem2,…},x] gives the list of elemi to which x is nearest. 

Nearest[{elem1->v1,elem2->v2,…},x] gives the vi corresponding to the elemi to which x is nearest. 

Nearest[{elem1,elem2,…}->{v1,v2,…},x] gives the same result. 

Nearest[{elem1,elem2,…}->prop,x] gives the property prop for the elemi to which x is nearest.

Nearest[data,{x1,x2,…}] effectively gives {Nearest[data,x1],Nearest[data,x2],…}.

Nearest[data,x,n] gives the n nearest elemi to x. 

Nearest[data,x,{n,r}] gives the n or fewer nearest elemi to x that are within radius r of x.

Nearest[data] generates a NearestFunction[…] that can be applied repeatedly to different x. 

NearestFunction

NearestFunction[data] represents a function whose values give the elements closest to an element that is supplied.

NearestNeighborG

NearestNeighborG[pdata,r] estimates the nearest neighbor function G(r) at radius r in the point data pdata.

NearestNeighborG[pproc,r] computes G(r) for the point process pproc.

NearestNeighborG[bdata,r] computes G(r) for binned data bdata. 

NearestNeighborG[pspec] generates the function G that can be applied repeatedly to different radii r.

NearestNeighborGraph

NearestNeighborGraph[{elem1,elem2,…}] gives a graph with vertices elem1,elem2,… and edges connecting each elemi to its nearest neighbors.

NearestNeighborGraph[{elem1,elem2,…},k] gives a graph connecting each elemi to its k nearest neighbors.

NearestNeighborGraph[{elem1,elem2,…},{k,r}] gives a graph connecting each elemi to at most k nearest vertices within radius r of elemi.

NearestNeighborGraph[{elem1,elem2,…},{All,r}] gives a graph connecting each elemi to all vertices within radius r of elemi.

NearestTo

NearestTo[x] is an operator form that yields Nearest[elems,x] when applied to a list elems.

NearestTo[x,n] is an operator form that yields Nearest[elems,x,n] when applied to a list elems.

NearestTo[x,{n,r}] is an operator form that yields Nearest[elems,x,{n,r}] when applied to a list elems.

NebulaData

NebulaData[entity,property] gives the value of the specified property for the nebula entity.

NebulaData[{entity1,entity2,…},property] gives a list of property values for the specified nebula entities.

NebulaData[entity,property,annotation] gives the specified annotation associated with the given property.

NeedlemanWunschSimilarity

NeedlemanWunschSimilarity[u,v] gives a number representing the Needleman–Wunsch similarity between strings or vectors u and v.

NeedlemanWunschSimilarity[u,v] gives a number representing the Needleman–Wunsch similarity between strings, vectors or biomolecular sequences u and v.

Needs

Needs["context`"] loads an appropriate file if the specified context is not already in $Packages. 

Needs["context`"->"alias`"] loads the given context and establishes alias as a context alias for that context.

Needs["context`","file"] loads file if the specified context is not already in $Packages. 

Negative

Negative[x] gives True if x is a negative number. 

NegativeBinomialDistribution

NegativeBinomialDistribution[n,p] represents a negative binomial distribution with parameters n and p.

NegativeDefiniteMatrixQ

NegativeDefiniteMatrixQ[m] gives True if m is explicitly negative definite, and False otherwise.

NegativeIntegers

NegativeIntegers represents the domain of strictly negative integers, as in x∈NegativeIntegers. 

NegativelyOrientedPoints

NegativelyOrientedPoints[{p1,p2,p3,…,pn}] tests whether the sequence of points p1,p2,p3,…,pn is negatively oriented.

NegativeMultinomialDistribution

NegativeMultinomialDistribution[n,p] represents a negative multinomial distribution with parameter n and failure probability vector p.

NegativeRationals

NegativeRationals represents the domain of strictly negative rational numbers, as in x∈NegativeRationals. 

NegativeReals

NegativeReals represents the domain of strictly negative real numbers.

NegativeSemidefiniteMatrixQ

NegativeSemidefiniteMatrixQ[m] gives True if m is explicitly negative semidefinite, and False otherwise.

NeighborhoodData

NeighborhoodData[entity,property] gives the value of the specified property for the neighborhood entity.

NeighborhoodData[{entity1,entity2,…},property] gives a list of property values for the specified neighborhood entities.

NeighborhoodData[entity,property,annotation] gives the specified annotation associated with the given property.

NeighborhoodGraph

NeighborhoodGraph[g,v] gives the graph neighborhood of a vertex v in the graph g.

NeighborhoodGraph[g,{a1,a2,…}] gives the graph neighborhood of the ai that can be vertices, edges, or subgraphs of g.

NeighborhoodGraph[g,patt] gives the graph neighborhood of the vertices and edges that match the pattern patt.

NeighborhoodGraph[g,…,d] gives the neighborhood up to distance d.

NeighborhoodGraph[{v->w,…},…] uses rules v->w to specify the graph g.

Nest

Nest[f,expr,n] gives an expression with f applied n times to expr.

Nest[f,n] represents an operator form of Nest that can be applied to expressions.

NestedGreaterGreater

NestedGreaterGreater[x,y,…] displays as x⪢y⪢….

NestedLessLess

NestedLessLess[x,y,…] displays as x⪡y⪡….

NestGraph

NestGraph[f,expr,n] gives the graph obtained by starting with expr and applying f successively n times.

NestGraph[f,{expr1,expr2,…},n] gives the graph obtained by applying f to expr1, expr2, ….

NestGraph[f,graph,n] gives the graph obtained by applying f to the vertices of graph and extending the graph.

NestList

NestList[f,expr,n] gives a list of the results of applying f to expr 0 through n times.

NestList[f,n] represents an operator form of NestList that can be applied to expressions.

NestTree

NestTree[f,tree] adds children to each leaf of tree, with f[expr] giving the list of data for the new children of a leaf with data expr.

NestTree[f,tree,n] successively applies f to the data of each leaf up to level n, adding at most n levels to each leaf.

NestTree[f,tree,n,h] additionally applies h to the data of the new subtrees.

NestTree[f,expr,…] constructs a tree by nesting f on the tree leaf with data expr.

NestWhile

NestWhile[f,expr,test] starts with expr, then repeatedly applies f until applying test to the result no longer yields True. 

NestWhile[f,expr,test,m] supplies the most recent m results as arguments for test at each step. 

NestWhile[f,expr,test,All] supplies all results so far as arguments for test at each step. 

NestWhile[f,expr,test,m,max] applies f at most max times. 

NestWhile[f,expr,test,m,max,n] applies f an extra n times. 

NestWhile[f,expr,test,m,max,-n] returns the result found when f had been applied n fewer times. 

NestWhileList

NestWhileList[f,expr,test] generates a list of the results of applying f repeatedly, starting with expr, and continuing until applying test to the result no longer yields True. 

NestWhileList[f,expr,test,m] supplies the most recent m results as arguments for test at each step. 

NestWhileList[f,expr,test,All] supplies all results so far as arguments for test at each step. 

NestWhileList[f,expr,test,m,max] applies f at most max times. 

NetAppend

NetAppend[net,layer] appends a layer or a net onto a NetChain, a layer or a NetGraph with one output port.

NetAppend[net,"name"->layer] appends a layer with a given name.

NetAppend[net,{layer1,layer2,…}] appends several layers or nets.

NetArray

NetArray[] represents an array in a net.

NetArray["name"] uses "name" as an identifier to share the array in more than one layer.

NetArray[prop->value] specifies the property prop for the array.

NetArray[<|"Name"->name,"Array"->array,…|>] specifies several properties for the array.

NetArrayLayer

NetArrayLayer[] represents a layer that has no input and produces as output a constant array.

NetArrayLayer[opts] includes options for the initial value of the array or output size.

NetBidirectionalOperator

NetBidirectionalOperator[net] represents a net that applies net to a sequence and to its reverse, concatenating both results into one output sequence.

NetBidirectionalOperator[{fnet,bnet}] uses fnet on the normal input and bnet on the reversed input.

NetBidirectionalOperator[nets,agg] aggregates the two output sequences using the specified aggregation function.

NetChain

NetChain[{layer1,layer2,…}] specifies a neural net in which the output of layeri is connected to the input of layeri+1.

NetChain[<|name1->layer1,name2->layer2,…|>] specifies a net consisting of a chain of explicitly named layers. 

NetDecoder

NetDecoder["name"] represents a decoder that takes a net representation and decodes it into an expression of a given form.

NetDecoder[{"name",…}] represents a decoder with additional parameters specified.

NetDelete

NetDelete[net,n] deletes the nth layer from a NetChain or NetGraph.

NetDelete[net,"name"] deletes a named layer.

NetDelete[net,{spec1,spec2,…}] deletes several layers simultaneously.

NetDelete[graph,NetPort["name"]] deletes an output or state-input port from a NetGraph.

NetDelete[graph,{NetPort[name1],NetPort[name2],…}] deletes several output or state-input ports simultaneously.

NetDrop

NetDrop[chain,n] removes the first n layers from a NetChain.

NetDrop[chain,-n] removes the last n layers from a NetChain.

NetDrop[chain,{start,end}] drops the layers between start and end in a NetChain.

NetEncoder

NetEncoder["name"] represents an encoder that takes a given form of input and encodes it as an array for use in a net.

NetEncoder[{"name",…}] represents an encoder with additional parameters specified.

NetEvaluationMode

NetEvaluationMode is an option that can be given when applying neural net functions to input data, specifying whether the net should use training-specific behavior.

NetExtract

NetExtract[layer,"param"] extracts the value of a parameter for the specified net layer.

NetExtract[net,lspec] extracts the layer identified by lspec from within the NetGraph or NetChain object net.

NetExtract[net,{lspec,"param"}] extracts the value of the parameter param from the layer identified by lspec in net. 

NetExtract[net,NetArray[spec]] extracts the value of a shared array within a network or layer.

NetExtract[coder,"param"] extracts the value of a parameter for the specified NetEncoder or NetDecoder.

NetExtract[…,{spec1,spec2,…}] extracts a set of elements, where each speci is a list.

NetFlatten

NetFlatten[net] collapses nested NetChain and NetGraph objects within net.

NetFlatten[net,n] collapses up to nesting level n.

NetFoldOperator

NetFoldOperator[net] represents a net in which net is folded over a sequence of inputs, maintaining a recurrent state.

NetFoldOperator[net,{outi->in1,…}] represents a net in which net is folded over its inputs, maintaining a recurrent state by feeding the outi of each step back to the ini of the next step.

NetFoldOperator[net,feedback,{const1,const2,…}] treats the inputs consti to net as being constant instead of mapped over.

NetFoldOperator[net,feedback,constants,{out1,…}] returns the sequence of values for the specific outputs outi.

NetGANOperator

NetGANOperator[{generator,discriminator}] represents a network to perform generative adversarial network (GAN) training with a generative net generator and a classification net discriminator.

NetGANOperator[{generator,discriminator},loss] specifies the loss type to be used.

NetGraph

NetGraph[{layer1,layer2,…},{m1->n1,m2->n2,…}] specifies a neural net defined by a graph in which the output of layer mi is given as input to layer ni.

NetGraph[<|name1->layer1,name2->layer2,…|>,{namem1->namen1,…}] specifies a net with explicitly named layers.

NetGraph[layer] converts a layer or a NetChain into an equivalent minimal NetGraph.

NetInformation

NetInformation[net] gives a report about the neural network net.

NetInformation[net,"prop"] gives the value of property property "prop" of net.

NetInformation[{net1,net2,…},"prop"] gives a list containing the result for each neti.

NetInitialize

NetInitialize[net] gives a net in which all uninitialized learnable parameters in net have been given initial values.

NetInitialize[net,All] gives a net in which all learnable parameters have been given initial values. 

NetInsert

NetInsert[chain,layer,i] inserts a layer into a NetChain before the layer at position i.

NetInsert[chain,"name"->layer,"pos"] inserts a named layer into a NetChain before the layer at the given position.

NetInsertSharedArrays

NetInsertSharedArrays[net] converts all ordinary arrays in net into NetSharedArray objects.

NetInsertSharedArrays[net,"prefix"] uses a prefix for the names of all newly shared arrays. 

NetJoin

NetJoin[net1,net2,…] connects a series of NetChain or NetGraph objects to form a single NetChain or NetGraph.

NetMapOperator

NetMapOperator[net] represents a net in which net is mapped over a sequence of inputs to give a sequence of outputs.

NetMapThreadOperator

NetMapThreadOperator[mapnet] represents a net in which mapnet is mapped over one or more inputs to give one or more outputs.

NetMapThreadOperator[mapnet,n] represents a net in which mapnet is mapped over its inputs at depth n.

NetMapThreadOperator[mapnet,<|input1->n1,input2->n2,…|>] represents a net in which mapnet is mapped over the input named inputi at depth ni, and all other inputs are replicated.

NetMeasurements

NetMeasurements[net,data,measurement] computes the requested measurement for the net evaluated on data.

NetMeasurements[net,data,{mspec1,mspec2,…}] computes a list of measurements for the net evaluated on data.

NetModel

NetModel["name"] obtains a neural net model with the specified name from the Neural Net Repository. 

NetModel[{"name",param1->setting1,…}] obtains a specified model from a parameterized family of models.

NetModel[model,"prop"] gives property prop of the model.

NetModel[] gives a dataset of available pre-trained neural net models.

NetNestOperator

NetNestOperator[net,n] represents a net in which net is applied n times to the input.

NetPairEmbeddingOperator

NetPairEmbeddingOperator[net] represents a net that takes a pair of arrays, embeds them into a vector space using net, and outputs the distance under the embedding.

NetPairEmbeddingOperator[net,opts] includes options for distance function to use and other parameters.

NetPort

NetPort["port"] represents the specified input or output port for a complete net.

NetPort[{n,"port"}] represents the specified port for layer number n in a NetGraph or similar construct.

NetPort[{"name","port"}] represents the specified port for the layer with the specified name.

NetPort[spec,port] is treated as equivalent to NetPort[{spec,port}].

NetPort[{spec1,spec2,…,"port"}] permits access to the port of nested layers in a NetGraph or a NetChain.

NetPort[All,"States"] represents the set of all states in a net associated with recurrent layers such as LongShortTermMemoryLayer.

NetPortGradient

NetPortGradient["port"] represents the gradient of the output of a net with respect to the value of the specified input port. 

NetPortGradient["param"] represents the gradient of the output with respect to a learned parameter named param.

NetPortGradient[{layer1,layer2,…,"param"}] represents the gradient with respect to a parameter at a specific position in a net.

NetPortGradient[All] represents the gradients with respect to all inputs and parameters.

NetPrepend

NetPrepend[net,layer] prepends a layer or a net onto a NetChain, a layer or a NetGraph with one input port.

NetPrepend[net,"name"->layer] appends a layer with a given name.

NetPrepend[net,{layer1,layer2,…}] prepends several layers or nets.

NetRename

NetRename[net,"old"->"new"] gives a net in which the name old for a layer is replaced with new.

NetRename[net,NetPort["old"]->NetPort["new"]] gives a net in which the name old for an input or output port is replaced with new.

NetRename[net,{rule1,rule2,…}] performs all renamings specified by the rulei.

NetRename[net,f] uses a function f to map existing layer names to new names.

NetRename[net,rules,levelspec] renames layers and ports nested at level levelspec.

NetReplace

NetReplace[net,patt->layer] gives a net in which all layers matching patt are replaced with layer.

NetReplace[net,{rule1,rule2,…}] performs all replacements specified by the rulei.

NetReplacePart

NetReplacePart[layer,"array"->value] replaces an array within a layer, returning a new layer.

NetReplacePart[net,"port"->type] returns a new layer or network in which an input or output port has the specified type.

NetReplacePart[net,"input"->encoder] attaches a NetEncoder[…] to a specified input port.

NetReplacePart[net,"output"->decoder] attaches a NetDecoder[…] to a specified output port.

NetReplacePart[net,lspec->layer] returns a new NetChain or NetGraph in which the layer identified by lspec has been replaced.

NetReplacePart[net,NetArray[name]->value] sets a shared array within a network or layer to a specified value.

NetReplacePart[coder,"param"->value] returns a new NetEncoder[…] or NetDecoder[…] in which a parameter has been replaced.

NetReplacePart[net,{lspec,pspec}->value] makes a replacement of a part pspec of a layer or coder lspec within a NetGraph or NetChain.

NetReplacePart[…,{spec1->val1,spec2->val2,…}] makes multiple simultaneous replacements.

NetSharedArray

NetSharedArray["name"] represents an array in a net that is shared by more than one layer.

NetStateObject

NetStateObject[net] creates an object derived from net that represents a neural net with additional stored state information that is updated when the net is applied to data.

NetStateObject[net,seed] creates an object in which additional stored state information is initialized using seed.

NetTake

NetTake[net,end] takes only those layers up to end in a NetChain or NetGraph.

NetTake[net,{start,end}] takes only those layers between start and end in a NetChain or NetGraph.

NetTrain

NetTrain[net,{input1->output1,input2->output2,…}] trains the specified neural net by giving the inputi as input and minimizing the discrepancy between the outputi and the actual output of the net, using an automatically chosen loss function.

NetTrain[net,<|port1->{data11,data12,…},port2->{…},…|>] trains the specified net by supplying training data at the specified ports.

NetTrain[net,"dataset"] trains on a named dataset from the Wolfram Data Repository.

NetTrain[net,f] calls the function f during training to produce batches of training data.

NetTrain[net,data,"prop"] gives data associated with a specific property prop of the training session.

NetTrain[net,data,All] gives a NetTrainResultsObject[…] that summarizes information about the training session.

NetTrainResultsObject

NetTrainResultsObject[…] represents an object generated by NetTrain that contains the trained net and other information about the training process.

NetUnfold

NetUnfold[fnet] produces the elementary net of the folded net fnet, exposing the recurrent states.

NetworkPacketCapture

NetworkPacketCapture[] creates a temporary interactive interface for capturing information on network packets transmitted or received through all network interfaces on your computer.

NetworkPacketCapture[service] captures only packets associated with the specified network service.

NetworkPacketCapture[port] captures only packets associated with the specified port.

NetworkPacketCapture[spec] captures only packets matching the specification spec. 

NetworkPacketRecording

NetworkPacketRecording[t] records information on network packets transmitted or received through all network interfaces on your computer for t seconds.

NetworkPacketRecording[t,service] records only packets associated with the specified network service.

NetworkPacketRecording[t,port] records only packets associated with the specified port.

NetworkPacketRecording[t,{port1,port2,…}] records only packets associated with any of the ports porti.

NetworkPacketRecording[t,spec] records only packets matching the specification spec. 

NetworkPacketTrace

NetworkPacketTrace[expr] evaluates expr and returns information on network packets transmitted or received through all network interfaces on your computer during the time of the evaluation, together with the result of the evaluation. 

NetworkPacketTrace[expr,service] records only packets associated with the specified network service.

NetworkPacketTrace[expr,port] records only packets associated with the specified port.

NetworkPacketTrace[expr,{port1,port2,…}] records only packets associated with any of the ports porti.

NetworkPacketTrace[expr,spec] records only packets matching the specification spec. 

NeumannValue

NeumannValue[val,pred] represents a Neumann boundary value val, specified on the part of the boundary of the region given to NDSolve and related functions where pred is True.

NevilleThetaC

NevilleThetaC[z,m] gives the Neville theta function ϑc (zm). 

NevilleThetaD

NevilleThetaD[z,m] gives the Neville theta function ϑd (zm). 

NevilleThetaN

NevilleThetaN[z,m] gives the Neville theta function ϑn (zm). 

NevilleThetaS

NevilleThetaS[z,m] gives the Neville theta function ϑs (zm). 

NExpectation

NExpectation[expr,xdist] gives the numerical expectation of expr under the assumption that x follows the probability distribution dist.

NExpectation[expr,{x1,x2,…}dist] gives the numerical expectation of expr under the assumption that {x1,x2,…} follows the multivariate distribution dist. 

NExpectation[expr,{x1dist1,x2dist2,…}] gives the numerical expectation of expr under the assumption that x1, x2, … are independent and follow the distributions dist1, dist2, …. 

NExpectation[exprpred,…] gives the numerical conditional expectation of expr given pred.

NextDate

NextDate[gran] gives the next occurring date of the specified granularity type gran.

NextDate[daytype] gives the next day corresponding to the specified daytype.

NextDate[date,gran] gives the next date of the given granularity relative to the specified date.

NextPrime

NextPrime[x] gives the smallest prime above x.

NextPrime[x,k] gives the kth-next prime above x.

NextScheduledTaskTime

NextScheduledTaskTime[obj] gives the next execution time of the scheduled task represented by obj.

NHoldAll

NHoldAll is an attribute which specifies that none of the arguments to a function should be affected by N. 

NHoldFirst

NHoldFirst is an attribute which specifies that the first argument to a function should not be affected by N. 

NHoldRest

NHoldRest is an attribute which specifies that all but the first argument to a function should not be affected by N. 

NicholsGridLines

NicholsGridLines is an option to NicholsPlot that specifies contours of constant magnitude and constant phase of the closed-loop system.

NicholsPlot

NicholsPlot[lsys] generates a Nichols plot of the transfer function for the system lsys.

NicholsPlot[lsys,{ωmin,ωmax}] plots for the frequency range ωmin to ωmax.

NicholsPlot[expr,{ω,ωmin,ωmax}] plots expr using the variable ω.

NightHemisphere

NightHemisphere[] is a two-dimensional GeoGraphics primitive that represents the half of the Earth currently in darkness.

NightHemisphere[datespec] represents the night half of the Earth for the specified date.

NIntegrate

NIntegrate[f,{x,xmin,xmax}] gives a numerical approximation to the integral ∫xminxmax f dx. 

NIntegrate[f,{x,xmin,xmax},{y,ymin,ymax},…] gives a numerical approximation to the multiple integral ∫xminxmaxdx∫yminymaxdy … f.

NIntegrate[f,{x,y,…}∈reg] integrates over the geometric region reg.

NMaximize

NMaximize[f,x] searches for a global maximum in f numerically with respect to x.

NMaximize[f,{x,y,…}] searches for a global maximum in f numerically with respect to x, y, …. 

NMaximize[{f,cons},{x,y,…}] searches for a global maximum in f numerically subject to the constraints cons. 

NMaximize[…,x∈rdom] constrains x to be in the region or domain rdom.

NMaxValue

NMaxValue[f,x] gives the global maximum value of f with respect to x.

NMaxValue[f,{x,y,…}] gives the global maximum value of f with respect to x, y, …. 

NMaxValue[{f,cons},{x,y,…}] gives the global maximum value of f subject to the constraints cons. 

NMaxValue[…,x∈reg] constrains x to be in the region reg.

NMinimize

NMinimize[f,x] searches for a global minimum in f numerically with respect to x.

NMinimize[f,{x,y,…}] searches for a global minimum in f numerically with respect to x, y, ….

NMinimize[{f,cons},{x,y,…}] searches for a global minimum in f numerically subject to the constraints cons. 

NMinimize[…,x∈rdom] constrains x to be in the region or domain rdom.

NMinValue

NMinValue[f,x] gives the global minimum value of f with respect to x.

NMinValue[f,{x,y,…}] gives the global minimum value of f with respect to x, y, …. 

NMinValue[{f,cons},{x,y,…}] gives the global minimum value of f subject to the constraints cons.

NMinValue[…,x∈reg] constrains x to be in the region reg.

NominalVariables

NominalVariables is an option for statistical functions such as LinearModelFit that specifies which variables should be treated as having discrete values specified by names.

NoncentralBetaDistribution

NoncentralBetaDistribution[α,β,δ] represents a noncentral beta distribution with shape parameters α, β and noncentrality parameter δ.

NoncentralChiSquareDistribution

NoncentralChiSquareDistribution[ν,λ] represents a noncentral χ2 distribution with ν degrees of freedom and noncentrality parameter λ.

NoncentralFRatioDistribution

NoncentralFRatioDistribution[n,m,λ] represents a noncentral F-ratio distribution with n numerator degrees of freedom, m denominator degrees of freedom, and numerator noncentrality parameter λ.

NoncentralFRatioDistribution[n,m,λ, η] represents a doubly noncentral F-ratio distribution with numerator noncentrality parameter λ and denominator noncentrality parameter η.

NoncentralStudentTDistribution

NoncentralStudentTDistribution[ν,δ] represents a noncentral Student t distribution with ν degrees of freedom and noncentrality parameter δ.

NonCommutativeMultiply

a**b**c is a general associative, but non‐commutative, form of multiplication. 

NonConstants

NonConstants is an option for D which gives a list of objects to be taken to depend implicitly on the differentiation variables. 

NondimensionalizationTransform

NondimensionalizationTransform[eq,ovars,fvars] nondimensionalizes eq, replacing original variables ovars with the variables fvars.

NondimensionalizationTransform[eq,ovars,fvars,prop] returns a property associated with the nondimensionalization of eq.

None

None is a setting used for certain options. 

NoneTrue

NoneTrue[{e1,e2,…},test] yields True if test[ei] is False for all of the ei.

NoneTrue[expr,test,level] tests parts of expr at level level.

NoneTrue[test] represents an operator form of NoneTrue that can be applied to an expression.

NonlinearModelFit

NonlinearModelFit[{{x1,y1},{x2,y2},…},form,{β1,…},x] constructs a nonlinear model with formula form that fits the yi for each xi using the free parameters βi.

NonlinearModelFit[data,form,params,{x1,…}] constructs a nonlinear model where form depends on the variables xk. 

NonlinearModelFit[data,{form,cons},params,{x1,…}] constructs a nonlinear model subject to the parameter constraints cons.

NonlinearStateSpaceModel

NonlinearStateSpaceModel[{f,g},x,u] represents the model x'(t)f(x(t),u(t)), y(t)g(x(t),u(t)).

NonlinearStateSpaceModel[sys] gives a state-space representation corresponding to the systems model sys. 

NonlinearStateSpaceModel[eqns,{{x1,x10},…},{{u1,u10},…},{g1,…},t] gives the state-space model of the differential equations eqns with dependent variables xi, input variables ui, operating values xi0 and ui0, outputs gi, and independent variable t.

NonlocalMeansFilter

NonlocalMeansFilter[image,r] applies a nonlocal means filter to image by comparing a range r neighborhood to its nearby neighborhoods.

NonlocalMeansFilter[image,r,ns] assumes an additive noise power value ns for comparing neighborhoods.

NonlocalMeansFilter[image,r,ns,w] compares neighborhoods in a range w window.

NonNegative

NonNegative[x] gives True if x is a non‐negative number. 

NonNegativeIntegers

NonNegativeIntegers represents the domain of non-negative integers, as in x∈NonNegativeIntegers. 

NonNegativeRationals

NonNegativeRationals represents the domain of non-negative rational numbers, as in x∈NonNegativeRationals. 

NonNegativeReals

NonNegativeReals represents the domain of non-negative real numbers.

NonPositive

NonPositive[x] gives True if x is a non‐positive number. 

NonPositiveIntegers

NonPositiveIntegers represents the domain of non-positive integers, as in x∈NonPositiveIntegers. 

NonPositiveRationals

NonPositiveRationals represents the domain of non-positive rational numbers, as in x∈NonPositiveRationals. 

NonPositiveReals

NonPositiveReals represents the domain of non-positive real numbers.

Nor

Nor[e1,e2,…] is the logical NOR function. It evaluates its arguments in order, giving False immediately if any of them are True, and True if they are all False. 

NorlundB

NorlundB[n,a] gives Nørlund polynomials Bn(a) of degree n in a.

NorlundB[n,a,x] gives generalized Bernoulli polynomials Bn(a)(x).

Norm

Norm[expr] gives the norm of a number, vector, or matrix. 

Norm[expr,p] gives the p‐norm. 

Normal

Normal[expr] converts expr to a normal expression from a variety of special forms. 

Normal[expr,h] converts objects with head h in expr to normal expressions.

Normal[expr,{h1,h2,…}] converts objects with head hi to normal expressions.

NormalDistribution

NormalDistribution[μ,σ] represents a normal (Gaussian) distribution with mean μ and standard deviation σ.

NormalDistribution[] represents a normal distribution with zero mean and unit standard deviation.

NormalizationLayer

NormalizationLayer[] represents a trainable net layer that normalizes its input data across the second and subsequent dimensions and applies an independent scaling and bias to each component of the first dimension.

NormalizationLayer[aggregationlevels] normalizes data across the specified aggregation levels and applies a learned scaling and bias on the remaining levels.

NormalizationLayer[aggregationlevels,scalinglevels] applies a learned scaling and bias at the specified scaling levels.

Normalize

Normalize[v] gives the normalized form of a vector v. 

Normalize[z] gives the normalized form of a complex number z.

Normalize[expr,f] normalizes with respect to the norm function f.

Normalized

Normalized is an option that determines whether to test if matrix columns or rows are normalized.

NormalizedSquaredEuclideanDistance

NormalizedSquaredEuclideanDistance[u,v] gives the normalized squared Euclidean distance between vectors u and v.

NormalMatrixQ

NormalMatrixQ[m] gives True if m is an explicitly normal matrix, and False otherwise.

NormalsFunction

NormalsFunction is an option for Plot3D and related functions that specifies a function to apply to determine the effective surface normals at every point.

NormFunction

NormFunction is an option for functions such as FindFit and NDSolve which gives a function to be minimized in generating results.

Not

!expr is the logical NOT function. It gives False if expr is True, and True if it is False. 

NotCongruent

NotCongruent[x,y,…] displays as x≢y≢….

NotCupCap

NotCupCap[x,y,…] displays as x≭y≭….

NotDoubleVerticalBar

NotDoubleVerticalBar[x,y,…] displays as x∦y∦….

NotElement

NotElement[x,dom] or x∉dom asserts that x is not an element of the domain dom.

NotElement[x1|…|xn,dom] asserts that none of the xi are elements of dom.

NotElement[patt,dom] asserts that any expression matching the pattern patt is not an element of the domain dom.

NotEqualTilde

NotEqualTilde[x,y,…] displays as xy….

NotExists

NotExists[x,y] displays as ∄xy.

NotGreater

NotGreater[x,y,…] displays as x≯y≯….

NotGreaterEqual

NotGreaterEqual[x,y,…] displays as x≱y≱….

NotGreaterFullEqual

NotGreaterFullEqual[x,y,…] displays as x≩y≩….

NotGreaterGreater

NotGreaterGreater[x,y,…] displays as xy….

NotGreaterLess

NotGreaterLess[x,y,…] displays as x≹y≹….

NotGreaterSlantEqual

NotGreaterSlantEqual[x,y,…] displays as xy….

NotGreaterTilde

NotGreaterTilde[x,y,…] displays as x≵y≵….

Nothing

Nothing represents an element of a list that will automatically be removed. 

Nothing[…] gives Nothing.

NotHumpDownHump

NotHumpDownHump[x,y,…] displays as xy….

NotHumpEqual

NotHumpEqual[x,y,…] displays as xy….

NotificationFunction

NotificationFunction is an option that specifies how notifications should be sent from background tasks.

NotLeftTriangle

NotLeftTriangle[x,y,…] displays as x⋪y⋪….

NotLeftTriangleBar

NotLeftTriangleBar[x,y,…] displays as xy….

NotLeftTriangleEqual

NotLeftTriangleEqual[x,y,…] displays as x⋬y⋬….

NotLess

NotLess[x,y,…] displays as x≮y≮….

NotLessEqual

NotLessEqual[x,y,…] displays as x≰y≰….

NotLessFullEqual

NotLessFullEqual[x,y,…] displays as x≨y≨….

NotLessGreater

NotLessGreater[x,y,…] displays as x≸y≸….

NotLessLess

NotLessLess[x,y,…] displays as xy….

NotLessSlantEqual

NotLessSlantEqual[x,y,…] displays as xy….

NotLessTilde

NotLessTilde[x,y,…] displays as x≴y≴….

NotNestedGreaterGreater

NotNestedGreaterGreater[x,y,…] displays as xy….

NotNestedLessLess

NotNestedLessLess[x,y,…] displays as xy….

NotPrecedes

NotPrecedes[x,y,…] displays as x⊀y⊀….

NotPrecedesEqual

NotPrecedesEqual[x,y,…] displays as xy….

NotPrecedesSlantEqual

NotPrecedesSlantEqual[x,y,…] displays as x⋠y⋠….

NotPrecedesTilde

NotPrecedesTilde[x,y,…] displays as x⋨y⋨….

NotReverseElement

NotReverseElement[x,y,…] displays as x∌y∌….

NotRightTriangle

NotRightTriangle[x,y,…] displays as x⋫y⋫….

NotRightTriangleBar

NotRightTriangleBar[x,y,…] displays as xy….

NotRightTriangleEqual

NotRightTriangleEqual[x,y,…] displays as x⋭y⋭….

NotSquareSubset

NotSquareSubset[x,y,…] displays as xy….

NotSquareSubsetEqual

NotSquareSubsetEqual[x,y,…] displays as x⋢y⋢….

NotSquareSuperset

NotSquareSuperset[x,y,…] displays as xy….

NotSquareSupersetEqual

NotSquareSupersetEqual[x,y,…] displays as x⋣y⋣….

NotSubset

NotSubset[x,y,…] displays as x⊄y⊄….

NotSubsetEqual

NotSubsetEqual[x,y,…] displays as x⊈y⊈….

NotSucceeds

NotSucceeds[x,y,…] displays as x⊁y⊁….

NotSucceedsEqual

NotSucceedsEqual[x,y,…] displays as xy….

NotSucceedsSlantEqual

NotSucceedsSlantEqual[x,y,…] displays as x⋡y⋡….

NotSucceedsTilde

NotSucceedsTilde[x,y,…] displays as x⋩y⋩….

NotSuperset

NotSuperset[x,y,…] displays as x⊅y⊅….

NotSupersetEqual

NotSupersetEqual[x,y,…] displays as x⊉y⊉….

NotTilde

NotTilde[x,y,…] displays as x≁y≁….

NotTildeEqual

NotTildeEqual[x,y,…] displays as x≄y≄….

NotTildeFullEqual

NotTildeFullEqual[x,y,…] displays as x≇y≇….

NotTildeTilde

NotTildeTilde[x,y,…] displays as x≉y≉….

NotVerticalBar

NotVerticalBar[x,y,…] displays as xy….

Now

Now gives a DateObject representing the current moment in time.

NoWhitespace

NoWhitespace represents the absence of whitespace between elements in a grammar rules pattern.

NProbability

NProbability[pred,xdist] gives the numerical probability for an event that satisfies the predicate pred under the assumption that x follows the probability distribution dist. 

NProbability[pred,{x1,x2,…}dist] gives the numerical probability that an event satisfies pred under the assumption that {x1,x2,…} follows the multivariate distribution dist. 

NProbability[pred,{x1dist1,x2dist2,…}] gives the numerical probability that an event satisfies pred under the assumption that x1, x2, … are independent and follow the distributions dist1, dist2, …. 

NProbability[pred1pred2,…] gives the numerical conditional probability of pred1 given pred2. 

NProduct

NProduct[f,{i,imin,imax}] gives a numerical approximation to the product ∏+i=imin%imaxf.

NProduct[f,{i,imin,imax,di}] uses a step di in the product. 

NProductFactors

NProductFactors is an option for NProduct. NProductFactors -> n explicitly includes n factors in the product before extrapolation.

NRoots

NRoots[lhs==rhs,var] yields a disjunction of equations which represent numerical approximations to the roots of a polynomial equation. 

NSolve

NSolve[expr,vars] attempts to find numerical approximations to the solutions of the system expr of equations or inequalities for the variables vars. 

NSolve[expr,vars,Reals] finds solutions over the domain of real numbers.

NSolveValues

NSolveValues[expr,vars] attempts to find numerical approximations to the values of vars determined by the solutions of the system expr.

NSolveValues[expr,vars,Reals] finds solutions over the domain of real numbers.

NSum

NSum[f,{i,imin,imax}] gives a numerical approximation to the sum ∑+i=imin%imaxf.

NSum[f,{i,imin,imax,di}] uses a step di in the sum. 

NSumTerms

NSumTerms is an option for NSum. NSumTerms -> n explicitly includes n terms in the sum before extrapolation.

NuclearExplosionData

NuclearExplosionData[entity,property] gives the value of the specified property for the nuclear explosion entity.

NuclearExplosionData[{entity1,entity2,…},property] gives a list of property values for the specified nuclear explosion entities.

NuclearExplosionData[entity,property,annotation] gives the specified annotation associated with the given property.

NuclearReactorData

NuclearReactorData[entity,property] gives the value of the specified property for the nuclear reactor entity.

NuclearReactorData[{entity1,entity2,…},property] gives a list of property values for the specified nuclear reactor entities.

NuclearReactorData[entity,property,annotation] gives the specified annotation associated with the given property.

Null

Null is a symbol used to indicate the absence of an expression or a result. When it appears as a complete output expression, no output is printed. 

NullRecords

NullRecords is an option for Read and related functions which specifies whether null records should be taken to exist between repeated record separators. 

NullSpace

NullSpace[m] gives a list of vectors that forms a basis for the null space of the matrix m. 

NullWords

NullWords is an option for Read and related functions which specifies whether null words should be taken to exist between repeated word separators. 

Number

Number represents an exact integer or an approximate real number in Read. 

NumberCompose

NumberCompose[{c1,…,cn},{u1,…,un}] returns the quantity c1 u1+…+cn un.

NumberDecompose

NumberDecompose[x,{u1,…,un}] returns a list of coefficients {c1,…,cn} of a decomposition of the number x in the basis {u1,…,un}.

NumberDigit

NumberDigit[x,n] returns the digit corresponding to 10n in the real-valued number x.

NumberDigit[x,n,b] returns the digit corresponding to bn.

NumberExpand

NumberExpand[x] gives a list of the decimal digits of x multiplied by their corresponding powers of 10. 

NumberExpand[x,b] expands x in base b.

NumberExpand[x,b,len] gives a list of length len.

NumberFieldClassNumber

NumberFieldClassNumber[θ] gives the class number for the algebraic number field [θ] generated by θ.

NumberFieldDiscriminant

NumberFieldDiscriminant[a] gives the discriminant of the field [a] generated by the algebraic number a.

NumberFieldFundamentalUnits

NumberFieldFundamentalUnits[a] gives a list of fundamental units for the field [a] generated by the algebraic number a.

NumberFieldIntegralBasis

NumberFieldIntegralBasis[a] gives an integral basis for the field [a] generated by the algebraic number a.

NumberFieldNormRepresentatives

NumberFieldNormRepresentatives[a,m] gives a list of representatives of classes of algebraic integers of norm ±m in the field [a] generated by the algebraic number a.

NumberFieldRegulator

NumberFieldRegulator[a] gives the regulator of the field [a] generated by the algebraic number a.

NumberFieldRootsOfUnity

NumberFieldRootsOfUnity[a] gives the roots of unity for the field [a] generated by the algebraic number a.

NumberFieldSignature

NumberFieldSignature[a] gives the signature of the field [a] generated by the algebraic number a.

NumberForm

NumberForm[expr,n] prints with approximate real numbers in expr given to n‐digit precision. 

NumberForm[expr,{n,f}] prints with approximate real numbers having n digits, with f digits to the right of the decimal point.

NumberForm[expr] prints using the default options of NumberForm.

NumberFormat

NumberFormat is an option for NumberForm and related functions that specifies how the mantissa, base, and exponent should be assembled into a final print form. 

NumberLinePlot

NumberLinePlot[{v1,v2,…}] plots the values vi on a number line.

NumberLinePlot[pred,x] plots a number line illustrating the region pred.

NumberLinePlot[pred,{x,xmin,xmax}] plots the number to extend over the interval from xmin to xmax.

NumberLinePlot[{spec1,spec2,…},…] plots several number lines.

NumberMarks

NumberMarks is an option for InputForm and related functions that specifies whether ` marks should be included in the printed forms of approximate numbers. 

NumberMultiplier

NumberMultiplier is an option for NumberForm and related functions which gives the string to use as a multiplication sign in scientific notation. 

NumberPadding

NumberPadding is an option for NumberForm and related functions which gives strings to use as padding on the left‐ and right‐hand sides of numbers. 

NumberPoint

NumberPoint is an option for NumberForm and related functions that gives the string to use as a decimal point. 

NumberQ

NumberQ[expr] gives True if expr is a number, and False otherwise. 

NumberSeparator

NumberSeparator is an option for NumberForm and related functions that gives the string to insert at breaks between digits. 

NumberSigns

NumberSigns is an option for NumberForm and related functions which gives strings to use as signs for negative and positive numbers. 

NumberString

NumberString represents the characters of a number in StringExpression.

Numerator

Numerator[expr] gives the numerator of expr. 

NumeratorDenominator

NumeratorDenominator[expr] gives the list {Numerator[expr],Denominator[expr]} of expr.

NumericalOrder

NumericalOrder[e1,e2] gives 1 if e1<e2, -1 if e1>e2, 0 if e1 and e2 are numerically the same, and orders by type or using canonical order if e1 and e2 are not numerically comparable.

NumericalSort

NumericalSort[list] sorts the elements of list into numerical order.

NumericArray

NumericArray[array,type] creates a numeric array of the specified type.

NumericArray[array,type,method] uses method to convert numbers into type.

NumericArrayQ

NumericArrayQ[expr] gives True if expr is a valid NumericArray object, and False otherwise.

NumericArrayQ[expr, tpatt] requires additionally that NumericArrayType[expr] match the pattern tpatt.

NumericArrayQ[expr,tpatt,dpatt] requires additionally that ArrayDepth[expr] match the pattern dpatt.

NumericArrayType

NumericArrayType[array] gives the underlying type of values used for each element in the NumericArray object.

NumericFunction

NumericFunction is an attribute that can be assigned to a symbol f to indicate that f[arg1,arg2,…] should be considered a numeric quantity whenever all the argi are numeric quantities. 

NumericQ

NumericQ[expr] gives True if expr is a numeric quantity, and False otherwise. 

NuttallWindow

NuttallWindow[x] represents a Nuttall window function of x.

NValues

NValues[f] gives a list of transformation rules corresponding to all numerical values (values for N[f[x,…],…], etc.) defined for the symbol f.

NyquistGridLines

NyquistGridLines is an option to NyquistPlot that specifies contours of constant magnitude and phase of a closed-loop system.

NyquistPlot

NyquistPlot[lsys] generates a Nyquist plot of the transfer function for the system lsys.

NyquistPlot[lsys,{ωmin,ωmax}] plots for the frequency range ωmin to ωmax.

NyquistPlot[expr,{ω,ωmin,ωmax}] plots expr using the variable ω.

O

O[x]^n represents a term of order xn. 

O[x]^n is generated to represent omitted higher‐order terms in power series. 

O[x,x0]^n represents a term of order (x-x0)n. 

ObjectExistsQ

System`ObjectExistsQ

ObservabilityGramian

ObservabilityGramian[ssm] gives the observability Gramian of the state-space model ssm.

ObservabilityMatrix

ObservabilityMatrix[ssm] gives the observability matrix of the state-space model ssm.

ObservableDecomposition

ObservableDecomposition[sys] yields the observable subsystem of the system sys.

ObservableDecomposition[sys,{z1,…}] specifies the new coordinates zi.

ObservableModelQ

ObservableModelQ[sys] gives True if the system sys is observable, and False otherwise.

ObservableModelQ[{sys,sub}] gives True if the subsystem sub is observable.

OceanData

OceanData[entity,property] gives the value of the specified property for the ocean entity.

OceanData[{entity1,entity2,…},property] gives a list of property values for the specified ocean entities.

OceanData[entity,property,annotation] gives the specified annotation associated with the given property.

Octahedron

Octahedron[] represents a regular octahedron centered at the origin with unit edge length.

Octahedron[l] represents an octahedron with edge length l.

Octahedron[{θ,ϕ},…] represents an octahedron rotated by an angle θ with respect to the z axis and angle ϕ with respect to the y axis.

Octahedron[{x,y,z},…] represents an octahedron centered at {x,y,z}.

OddQ

OddQ[expr] gives True if expr is an odd integer, and False otherwise. 

Off

Off[symbol::tag] switches off a message, so that it is no longer printed. 

Off["name"] switches off a named group of messages.

Off[s] switches off tracing messages associated with the symbol s. 

Off[m1,m2,…] switches off several messages or message groups. 

Offset

Offset[{dx,dy},position] gives the position of a graphical object obtained by starting at the specified position and then moving by absolute offset {dx,dy}. 

On

On[symbol::tag] switches on a message, so that it can be printed. 

On["name"] switches on a named group of messages.

On[s] switches on tracing for the symbol s. 

On[m1,m2,…] switches on several messages or message groups. 

ONanGroupON

ONanGroupON[] represents the sporadic simple O'Nan group O'N.

Once

Once[expr] evaluates expr once in each Wolfram Language session, always returning the result from the first evaluation.

Once[expr,loc] evaluates expr once and caches the result in persistence location loc.

OneIdentity

OneIdentity is an attribute that can be assigned to a symbol f to indicate that f[x], f[f[x]], etc. are all equivalent to x for the purpose of pattern matching. 

Opacity

Opacity[a] is a graphics directive that specifies that graphical objects that follow are to be displayed, if possible, with opacity a. 

Opacity[a,color] uses the specified color with opacity a.

OpacityFunction

OpacityFunction is an option for graphics functions that specifies a function to apply to determine opacity of elements.

OpacityFunctionScaling

OpacityFunctionScaling is an option to visualization functions such as DensityPlot3D that specifies whether arguments supplied to OpacityFunction should be scaled to lie between 0 and 1.

OpenAppend

OpenAppend["file"] opens a file to append output to it, and returns an OutputStream object. 

OpenerView

OpenerView[{expr1,expr2}] represents an object which displays as an opener, together with expr1 if the opener is closed, and both expr1 and expr2 if it is open.

OpenerView[{expr1,expr2},state] specifies the state of the opener, with False being closed, and True being open.

Opening

Opening[image,ker] gives the morphological opening of image with respect to the structuring element ker.

Opening[image,r] gives the opening with respect to a range-r square.

Opening[data,…] applies opening to an array of data.

OpenRead

OpenRead["file"] opens a file to read data from, and returns an InputStream object.

OpenTemporary

OpenTemporary[] opens a temporary file to which output can be written, and returns an OutputStream object. 

OpenWrite

OpenWrite["file"] opens a file to write output to it, and returns an OutputStream object. 

OpenWrite[] opens a new file in the default area for temporary files on your computer system.

Operate

Operate[p,f[x,y,…]] gives p[f][x,y,…]. 

Operate[p,expr,n] applies p at level n in the head of expr. 

OperatorApplied

OperatorApplied[f,n] represents an operator form of the function f of n arguments so that OperatorApplied[f,n][x1]…[xn] is equivalent to f[x1,…,xn].

OperatorApplied[f] represents an operator form of the function f of two arguments so that OperatorApplied[f][y][x] is equivalent to f[x,y].

OperatorApplied[f,{i1,…,in}] represents an operator form of the function f of n arguments so that OperatorApplied[f,{i1,…,in}][x1]…[xn] is equivalent to f[xi1,…,xin].

OperatorApplied[f,k->{i1,…,in}] represents an operator form that takes k arguments.

OptimumFlowData

OptimumFlowData[…] represents flow data such as generated by FindMaximumFlow, FindMinimumCostFlow, etc.

Optional

patt:def or Optional[patt,def] is a pattern object that represents an expression of the form patt, which, if omitted, should be replaced by the default value def. 

OptionalElement

OptionalElement[patt] is a grammar rules pattern object that represents 0 or 1 instances of patt.

OptionalElement[patt,default] uses default if the element is not present. 

OptionInspectorSettings

OptionInspectorSettings is a global option that specifies the display of options in the Option Inspector.

OptionQ

OptionQ[e] returns True if e can be considered an option or list of options, and False otherwise.

Options

Options[symbol] or Options["symbol"] gives the list of default options assigned to a symbol.

Options[expr] gives the options explicitly specified in a particular expression such as a graphics object.

Options[stream] gives options associated with a particular stream.

Options[object] gives options associated with an external object such as an NotebookObject or CloudObject.

Options[obj,name] gives the setting for the option name.

Options[obj,{name1,name2,…}] gives a list of the settings for the options namei.

OptionsPattern

OptionsPattern[] is a pattern object that represents a collection of options given as rules, where the values of the options can be accessed using OptionValue.

OptionsPattern[f] takes default option values from Options[f].

OptionsPattern[{opt1->val1,opt2->val2,…}] uses an explicit list of default option values.

OptionValue

OptionValue[name] gives the value of name in options matched by OptionsPattern. 

OptionValue[f,name] gives the value of name for options associated with the head f. 

OptionValue[f,opts,name] extracts option values from the explicit list of rules opts.

OptionValue[…,{name1,name2,…}] extracts several option values.

Or

e1||e2||… is the logical OR function. It evaluates its arguments in order, giving True immediately if any of them are True, and False if they are all False. 

Orange

Orange represents the color orange in graphics or style specifications. 

Order

Order[expr1,expr2] gives 1 if expr1 is before expr2 in canonical order, and -1 if expr1 is after expr2 in canonical order. It gives 0 if expr1 is identical to expr2. 

OrderDistribution

OrderDistribution[{dist,n},k] represents the kth-order statistics distribution for n observations from the distribution dist.

OrderDistribution[{dist,n},{k1,k2,…}] represents the joint (k1,k2,…)th-order statistics distribution from n observations from the distribution dist. 

OrderDistribution[{dist1,…,distn},…] represents the order statistics distribution for independent distributions disti.

OrderDistribution[mdist,…] represents the order statistics distribution for multivariate distribution mdist.

OrderedQ

OrderedQ[h[e1,e2,…]] gives True if the ei are in canonical order, and False otherwise.

OrderedQ[h[e1,e2,…],p] uses the ordering function p to determine whether each pair of elements ei, ei+1 is in order. 

Ordering

Ordering[list] gives the positions in list at which each successive element of Sort[list] appears. 

Ordering[list,n] gives the positions in list at which the first n elements of Sort[list] appear. 

Ordering[list,-n] gives the positions of the last n elements of Sort[list]. 

Ordering[list,n,p] gives positions in list of elements of Sort[list,p]. 

OrderingBy

OrderingBy[list,f] gives the positions in list at which each successive element of SortBy[list,f] appears.

OrderingBy[list,f,n] gives the positions in list at which the first n elements of SortBy[list,f] appear.

OrderingBy[list,f,-n] gives the positions of the last n elements of SortBy[list,f].

OrderingBy[list,f,n,p] gives positions in list of elements of SortBy[list,f,p].

OrderingBy[f] represents an operator form of OrderingBy that can be applied to an expression.

OrderingLayer

OrderingLayer[] represents a net layer that effectively applies Ordering to its input. 

OrderingLayer[n] gives the first n elements in the ordering of its input.

OrderingLayer[-n] gives the last n elements in the ordering of its input.

Orderless

Orderless is an attribute that can be assigned to a symbol f to indicate that the elements ei in expressions of the form f[e1,e2,…] should automatically be sorted into canonical order. This property is accounted for in pattern matching. 

OrderlessPatternSequence

OrderlessPatternSequence[p1,p2,…] is a pattern object that represents a sequence of arguments matching p1,p2,… in any order.

OrnsteinUhlenbeckProcess

OrnsteinUhlenbeckProcess[μ,σ,θ] represents a stationary Ornstein–Uhlenbeck process with long-term mean μ, volatility σ, and mean reversion speed θ. 

OrnsteinUhlenbeckProcess[μ,σ,θ,x0] represents an Ornstein–Uhlenbeck process with initial condition x0.

Orthogonalize

Orthogonalize[{v1,v2,…}] gives an orthonormal basis found by orthogonalizing the vectors vi.

Orthogonalize[{e1,e2,…},f] gives an orthonormal basis found by orthogonalizing the elements ei with respect to the inner product function f.

OrthogonalMatrixQ

OrthogonalMatrixQ[m] gives True if m is an explicitly orthogonal matrix, and False otherwise.

Out

%n or Out[n] is a global object that is assigned to be the value produced on the nth output line. 

% gives the last result generated. 

%% gives the result before last. %%…% (k times) gives the kth previous result. 

Outer

Outer[f,list1,list2,…] gives the generalized outer product of the listi, forming all possible combinations of the lowest‐level elements in each of them, and feeding them as arguments to f. 

Outer[f,list1,list2,…,n] treats as separate elements only sublists at level n in the listi. 

Outer[f,list1,list2,…,n1,n2,…] treats as separate elements only sublists at level ni in the corresponding listi. 

OuterPolygon

OuterPolygon[poly] gives the outer polygon of the polygon poly.

OuterPolyhedron

OuterPolyhedron[poly] gives the outer polyhedron of the polyhedron poly.

OutputAutoOverwrite

OutputAutoOverwrite is an option for notebooks that specifies whether the output of a command should replace any existing output from a previous evaluation.

OutputControllabilityMatrix

OutputControllabilityMatrix[ssm] gives the output controllability matrix of the state-space model ssm.

OutputControllableModelQ

OutputControllableModelQ[ssm] gives True if the state-space model ssm is output controllable, and False otherwise.

OutputForm

OutputForm[expr] prints as a two-dimensional representation of expr using only keyboard characters. 

OutputNamePacket

OutputNamePacket[string] is a WSTP packet that contains in string the name assigned to the next output.

OutputPorts

OutputPorts is an option to specify the number, names or shapes of output ports for some neural net layers.

OutputResponse

OutputResponse[sys,u[t],{t,tmin,tmax}] gives the numeric output response of systems model sys to the input u[t] for tmin≤t≤tmax.

OutputResponse[sys,{u[0],u[1],…}] gives the output response of the discrete-time system sys to the input sequence u[i].

OutputResponse[sys,u[t],t] gives the symbolic output response of system sys to the input u[t] as a function of time t.

OutputResponse[sys,{u1[t],…,um[t]},…] gives the output response for multiple inputs ui[t]. 

OutputSizeLimit

OutputSizeLimit is an option for notebooks that specifies the maximum size in bytes of expressions that will automatically be output in their entirety.

OutputStream

OutputStream["name",n] is an object that represents an output stream for functions such as Write. 

OverBar

OverBar[expr] displays with a bar over expr.

OverDot

OverDot[expr] displays with a dot over expr.

OverDot[expr,n] prints with n dots.

Overflow

Overflow[] represents a number too large to represent explicitly on your computer system.

OverHat

OverHat[expr] displays with a hat over expr.

Overlaps

Overlaps is an option to string and sequence functions that specifies how to treat overlapping substrings. 

Overlay

Overlay[{expr1,expr2,…}] displays as an overlay of all the expri.

Overlay[{expr1,expr2,…},{i,j,…}] displays as an overlay of expri, exprj, ….

Overlay[{expr1,expr2,…},{i,j,…},s] allows selections to be made and controls to be clicked in exprs.

OverlayVideo

OverlayVideo[background,o] gives the result of overlaying o onto a background video or image background. 

OverlayVideo[background,{o1,o2,…}] gives the result of overlaying o1, o2, …. 

OverlayVideo[background,{interval1->o1,…}] overlays each oi during the time interval intervali.

Overscript

Overscript[x,y] is an object that formats as x&y. 

OverTilde

OverTilde[expr] displays with a tilde over expr.

OverVector

OverVector[expr] displays with a right vector over expr.

OverwriteTarget

OverwriteTarget is an option for functions like CopyFile that specifies whether to overwrite if target files already exist.

OwenT

OwenT[x,a] gives Owen's T function T(x,a).

OwnValues

OwnValues[x] gives a list of transformation rules corresponding to all ownvalues defined for the symbol x.

OwnValues["symbol"] gives a list of transformation rules corresponding to all ownvalues defined for the symbol named "symbol" if it exists.

PackingMethod

PackingMethod is an option for GraphPlot and related functions that specifies how disconnected components should be packed together in the layout produced.

PackPaclet

The experimental function PackPaclet is now obsolete and is superseded by CreatePacletArchive.

PacletDataRebuild

PacletDataRebuild[] rescans all the installed paclets to rebuild the internal cache of paclet data.

PacletDirectoryAdd

The experimental function PacletDirectoryAdd is now obsolete and is superseded by PacletDirectoryLoad.

PacletDirectoryLoad

PacletDirectoryLoad[dir] makes paclets in dir visible in the current session.

PacletDirectoryLoad[{dir1,dir2, …}] makes paclets in all the diri visible in the current session.

PacletDirectoryRemove

StringTemplate[The experimental function `1` is now obsolete and is superseded by `2`., PacletDirectoryRemove, PacletDirectoryUnload]

PacletDirectoryUnload

PacletDirectoryUnload[dir] makes paclets in dir no longer visible in the current session.

PacletDirectoryUnload[{dir1,dir2, …}] makes paclets in all the diri no longer visible in the current session.

PacletDisable

PacletDisable[paclet] disables an installed paclet.

PacletEnable

PacletEnable[paclet] enables a previously disabled paclet.

PacletFind

PacletFind["name"] gives a list of installed paclets that match "name".

PacletFind["name"->"version"] gives a list of installed paclets that match "name" and "version".

PacletFind["name",<|prop1->val1,prop2->val2,…|>] gives a list of installed paclets that match "name" and criteria given by the propi->vali.

PacletFindRemote

PacletFindRemote["name"] gives a list of paclets that match "name" available on known paclet sites.

PacletFindRemote["name"->"version"] gives a list of paclets that match "name" and "version" available on known paclet sites.

PacletFindRemote["name",<|prop1->val1,prop2->val2,…|>] gives a list of paclets that match "name" and criteria given by the propi->vali available on known paclet sites.

PacletInformation

The experimental function PacletInformation is now obsolete. Use Information[PacletObject["pacletname"]], or property-extraction syntax like PacletObject["pacletname"]["prop"] or PacletObject["pacletname"][All] instead.

PacletInstall

PacletInstall[paclet] installs or updates paclet.

PacletInstall[task] waits for completion of the task started by a call to PacletInstallSubmit.

PacletInstallSubmit

PacletInstallSubmit[paclet] asynchronously installs or updates paclet.

PacletNewerQ

PacletNewerQ[paclet1,paclet2] returns True if paclet1 has a higher version number than paclet2, and False otherwise.

PacletObject

PacletObject[...] is the representation of a paclet in the Wolfram Language.

PacletObjectQ

PacletObjectQ[expr] returns True or False depending on whether its argument is a PacletObject expression.

PacletSite

PacletSite is an option for PacletInstall and PacletInstallSubmit that specifies the URL of a paclet site on which to look for the paclet.

PacletSiteObject

PacletSiteObject[assoc] represents a site from which paclets can be automatically downloaded.

PacletSiteRegister

PacletSiteRegister[url] registers url as a known paclet site.

PacletSiteRegister[url,name] registers url as a known paclet site with name.

PacletSiteRegister[PacletSiteObject[…]] registers the given PacletSiteObject as a known paclet site.

PacletSites

PacletSites[] gives the list of all paclet sites known to your system.

PacletSiteUnregister

PacletSiteUnregister[url] removes url from the list of registered paclet sites.

PacletSiteUnregister[name] removes the site named name from the list of registered paclet sites.

PacletSiteUnregister[PacletSiteObject[…]] removes the given PacletSiteObject from the list of registered paclet sites.

PacletSiteUpdate

PacletSiteUpdate[site] acquires and caches current information about the available paclets on the given paclet site.

PacletSymbol

PacletSymbol[paclet,"sym"] gives the symbol named "sym" in the primary context of paclet.

PacletSymbol[paclet,"sym",h] wraps the head h around the symbol before returning it.

PacletUninstall

PacletUninstall[paclet] uninstalls a paclet.

PacletUpdate

The experimental function PacletUpdate is now obsolete and is superseded by PacletInstall.

PaddedForm

PaddedForm[expr,n] prints with all numbers in expr padded to leave room for a total of n digits. 

PaddedForm[expr,{n,f}] prints with approximate real numbers having exactly f digits to the right of the decimal point. 

Padding

Padding is an option to various array and image operations that specifies what padding to use when extending beyond the original data specified.

PaddingLayer

PaddingLayer[{{m1,n1},{m2,n2},…}] represents a net layer that pads an input array with mi elements at the beginning and ni elements at the end at level i of the array.

PaddingSize

PaddingSize is an option in AudioDelay and other functions that specifies the amount of padding.

PadeApproximant

PadeApproximant[expr,{x,x0,{m,n}}] gives the Padé approximant to expr about the point x=x0, with numerator order m and denominator order n.

PadeApproximant[expr,{x,x0,n}] gives the diagonal Padé approximant to expr about the point x=x0 of order n.

PadLeft

PadLeft[list,n] makes a list of length n by padding list with zeros on the left. 

PadLeft[list,n,x] pads by repeating the element x. 

PadLeft[list,n,{x1,x2,…}] pads by cyclically repeating the elements xi. 

PadLeft[list,n,padding,m] leaves a margin of m elements of padding on the right. 

PadLeft[list,{n1,n2,…}] makes a nested list with length ni at level i. 

PadLeft[list] pads a ragged array list with zeros to make it full. 

PadRight

PadRight[list,n] makes a list of length n by padding list with zeros on the right. 

PadRight[list,n,x] pads by repeating the element x. 

PadRight[list,n,{x1,x2,…}] pads by cyclically repeating the elements xi. 

PadRight[list,n,padding,m] leaves a margin of m elements of padding on the left. 

PadRight[list,{n1,n2,…}] makes a nested list with length ni at level i. 

PadRight[list] pads a ragged array list with zeros to make it full. 

PageBreakAbove

PageBreakAbove is an option for Cell which specifies whether a page break should be made immediately above the cell if the notebook that contains the cell is printed. 

PageBreakBelow

PageBreakBelow is an option for Cell which specifies whether a page break should be made immediately below the cell if the notebook that contains the cell is printed. 

PageBreakWithin

PageBreakWithin is an option for Cell which specifies whether a page break should be allowed within the cell if the notebook that contains the cell is printed. 

PageFooterLines

PageFooterLines is an option for notebooks that specifies whether a horizontal line is inserted at the bottom of each page when the notebook is printed.

PageFooters

PageFooters is an option for notebooks that specifies what should be inserted as the footer of each page of a notebook when it is printed.

PageHeaderLines

PageHeaderLines is an option for notebooks that specifies whether a horizontal line is inserted at the top of each page when the notebook is printed.

PageHeaders

PageHeaders is an option for notebooks that specifies what should be inserted as the header of each page of a notebook when it is printed.

PageRankCentrality

PageRankCentrality[g,α] gives a list of page-rank centralities for the vertices in the graph g and weight α.

PageRankCentrality[g,α,β] gives a list of page-rank centralities, using weight α and initial centralities β.

PageRankCentrality[{v->w,…},…] uses rules v->w to specify the graph g. 

PageTheme

PageTheme is an option for FormObject, GalleryView, and related functions that specifies an overall theme for a webpage and its elements.

Pagination

Pagination is an option for GalleryView and related functions that specifies how pagination should be done in displayed output.

PairCorrelationG

PairCorrelationG[pdata,r] estimates the pair correlation function g(r) for point data pdata at radius r.

PairCorrelationG[pproc,r] computes g(r) for the point process pproc.

PairCorrelationG[bdata,r] computes g(r) for binned data bdata. 

PairCorrelationG[pspec] generates the function g that can be applied repeatedly to different radii r.

PairedBarChart

PairedBarChart[{y1,y2,…},{z1,z2,…}] makes a paired bar chart with bar lengths y1,  y2, … and z1, z2, …, respectively.

PairedBarChart[{…,wi[yi,…],…},{…,wj[zj,…],…}] makes a paired bar chart with bar features defined by the symbolic wrappers wk.

PairedBarChart[{data11,…},{data21,…}] makes a paired bar chart from multiple datasets data1i and data2j.

PairedHistogram

PairedHistogram[{x1,x2,…},{y1,y2,…}] plots a paired histogram of the values xi and yi.

PairedHistogram[{x1,x2,…},{y1,y2,…}, bspec] plots a paired histogram with bin width specification bspec.

PairedHistogram[{x1,x2,…},{y1,y2,…},bspec,hspec] plots a paired histogram with bin heights computed according to the specification hspec.

PairedHistogram[{data11,…},{data21,…},…] plots paired histograms for multiple datasets data1i and data2j.

PairedSmoothHistogram

PairedSmoothHistogram[{x1,x2,…},{y1,y2,…}] plots a paired smooth histogram of the values xi and yi.

PairedSmoothHistogram[{x1,x2,…},{y1,y2,…},espec] plots a paired smooth histogram with estimator specification espec.

PairedSmoothHistogram[{x1,x2,…},{y1,y2,…},espec,dfun] plots a paired smooth histogram with distribution function dfun.

PairedSmoothHistogram[{data11,…},{data21,…},…] plots paired smooth histograms for multiple datasets data1i and data2j.

PairedTTest

PairedTTest[data] tests whether the mean of data is zero. 

PairedTTest[{data1,data2}] tests whether the mean of data1– data2 is zero.

PairedTTest[dspec,μ0] tests a location measure against μ0.

PairedTTest[dspec,μ0,"property"] returns the value of "property".

PairedZTest

PairedZTest[data] tests whether the mean of the data is zero. 

PairedZTest[{data1,data2}] tests whether the means of data1 and data2 are equal.

PairedZTest[dspec,σ] tests for zero or equal means assuming a population variance σ.

PairedZTest[dspec,σ,μ0] tests the mean against μ0.

PairedZTest[dspec,σ,μ0,"property"] returns the value of "property".

PalindromeQ

PalindromeQ[list] returns True if the given list is identical to Reverse[list], and False otherwise.

PalindromeQ[n] returns True if the integer n is identical to IntegerReverse[n], and False otherwise.

PalindromeQ[string] returns True if the given string is identical to StringReverse[string], and False otherwise. 

Pane

Pane[expr] displays as a pane containing expr. 

Pane[expr,w] makes the pane be w printer's points wide, linewrapping the contents if necessary.

Pane[expr,{w,h}] makes the pane be w points wide and h points high, shrinking the contents if necessary.

Panel

Panel[expr] displays as a panel containing expr. 

Panel[expr,title] gives the panel the specified title. 

Panel[expr,title,pos] places title at a position specified by pos. 

Panel[expr,{title1,title2,…},{pos1,…}] places titlei at position posi. 

Panel[] displays an empty panel. 

Paneled

Paneled is an option for Manipulate and related functions that specifies whether to give the output inside a panel.

ParabolicCylinderD

ParabolicCylinderD[ν,z] gives the parabolic cylinder function Dν(z). 

ParallelArray

ParallelArray[f,n] generates in parallel a list of length n, with elements f[i], evaluated.

ParallelArray[f,{n1,n2,…}] generates in parallel an n1n2… array of nested lists, with elements f[i1,i2,…]. 

ParallelArray[f,{n1,n2,…},{r1,r2,…}] generates in parallel a list using the index origins ri (default 1). 

ParallelArray[f,dims,origin,h] uses head h, rather than List, for each level of the array. 

ParallelAxisPlot

ParallelAxisPlot[{{y11,…,y1n},…,{ym1,…,ymn}}] generates a parallel axis plot for the points {yi1,…,yin} using equally spaced axes.

ParallelAxisPlot[{data1,data2,…}] plots several sets of points.

ParallelCombine

ParallelCombine[f,h[e1,e2,…],comb] evaluates f[h[e1,e2,…]] in parallel by distributing parts of the computation to all parallel kernels and combining the partial results with comb.

ParallelCombine[f,h[e1,e2, …]] is equivalent to ParallelCombine[f,h[e1,e2,…],h] if h has attribute Flat, and ParallelCombine[f,h[e1,e2,…],Join] otherwise.

ParallelDo

ParallelDo[expr,{imax}] evaluates expr in parallel imax times. 

ParallelDo[expr,{i,imax}] evaluates expr in parallel with the variable i successively taking on the values 1 through imax (in steps of 1). 

ParallelDo[expr,{i,imin,imax}] starts with i=imin. 

ParallelDo[expr,{i,imin,imax,di}] uses steps di. 

ParallelDo[expr,{i,{i1,i2,…}}] uses the successive values i1, i2, ….

ParallelDo[expr,{i,imin,imax},{j,jmin,jmax},…] evaluates expr looping in parallel over different values of j, etc. for each i. 

Parallelepiped

Parallelepiped[p,{v1,…,vk}] represents a parallelepiped with origin p and directions vi.

ParallelEvaluate

ParallelEvaluate[expr] evaluates the expression expr on all available parallel kernels and returns the list of results obtained.

ParallelEvaluate[expr,kernel] evaluates expr on the parallel kernel specified. 

ParallelEvaluate[expr,{ker1,ker2,…}] evaluates expr on the parallel kernels keri.

ParallelEvaluate[expr,kernels,h] wraps the head h around the results before returning them.

Parallelization

Parallelization is an option for Compile that specifies whether it should create a compiled function that could run in parallel. 

Parallelize

Parallelize[expr] evaluates expr using automatic parallelization.

ParallelMap

ParallelMap[f,expr] applies f in parallel to each element on the first level in expr.

ParallelMap[f,expr,levelspec] applies f in parallel to parts of expr specified by levelspec.

ParallelNeeds

ParallelNeeds["context`"] evaluates Needs["context`"] on all available parallel kernels.

Parallelogram

Parallelogram[p,{v1,v2}] represents a parallelogram with origin p and directions v1 and v2.

ParallelSubmit

ParallelSubmit[expr] submits expr for evaluation on the next available parallel kernel and returns an EvaluationObject expression representing the submitted evaluation.

ParallelSubmit[{var1,var2, …},expr] builds a closure for the variables given before submitting expr.

ParallelTable

ParallelTable[expr,{imax}] generates in parallel a list of imax copies of expr.

ParallelTable[expr,{i,imax}] generates in parallel a list of the values of expr when i runs from 1 to imax. 

ParallelTable[expr,{i,imin,imax}] starts with i=imin. 

ParallelTable[expr,{i,imin,imax,di}] uses steps di. 

ParallelTable[expr,{i,{i1,i2,…}}] uses the successive values i1, i2, ….

ParallelTable[expr,{i,imin,imax},{j,jmin,jmax},…] gives a nested list. The list associated with i is outermost.

ParallelTry

ParallelTry[f,{arg1,arg2,…}] evaluates f[argi] in parallel, returning the first result received.

ParallelTry[f,{arg1,arg2,…},k] returns a list of the first k results.

ParameterEstimator

ParameterEstimator is an option to EstimatedDistribution and FindDistributionParameters that specifies what parameter estimator to use. 

ParameterMixtureDistribution

ParameterMixtureDistribution[dist[θ],θwdist] represents a parameter mixture distribution where the parameter θ is distributed according to the weight distribution wdist. 

ParameterMixtureDistribution[dist[θ1,θ2,…],{θ1wdist1,θ2wdist2,…}] represents a parameter mixture distribution where the parameter θ1 has weight distribution wdist1, θ2 has weight distribution wdist2, etc. 

ParameterVariables

ParameterVariables is an option for GroebnerBasis and PolynomialReduce. These variables will always be last in the ordering. By default, all variables that are not otherwise classified will become parameter variables. By specifying them explicitly one fixes their relative positions in the overall variable ordering.

ParametricConvexOptimization

ParametricConvexOptimization[f,cons,vars,pars] gives a ParametricFunction object that finds values of variables vars that minimize the convex objective function f subject to convex constraints cons with parameters pars.

ParametricConvexOptimization[…,"prop"] specifies what solution property "prop" should be returned by the ParametricFunction object.

ParametricFunction

ParametricFunction[pars,…] represents a function that computes a solution when evaluated with numerical values for the parameters pars. 

ParametricNDSolve

ParametricNDSolve[eqns,u,{x,xmin,xmax},pars] finds a numerical solution to the ordinary differential equations eqns for the function u with the independent variable x in the range xmin to xmax with parameters pars.

ParametricNDSolve[eqns,u,{x,xmin,xmax},{y,ymin,ymax},pars] solves the partial differential equations eqns over a rectangular region.

ParametricNDSolve[eqns,u,{x,y}∈Ω,pars] solves the partial differential equations eqns over the region Ω.

ParametricNDSolve[eqns,u,{t,tmin,tmax},{x,y}∈Ω,pars] solves the time-dependent partial differential equations eqns over the region Ω.

ParametricNDSolve[eqns,{u1,u2,…},…] solves for the functions ui. 

ParametricNDSolveValue

ParametricNDSolveValue[eqns,expr,{x,xmin,xmax},pars] gives the value of expr with functions determined by a numerical solution to the ordinary differential equations eqns with the independent variable x in the range xmin to xmax with parameters pars.

ParametricNDSolveValue[eqns,expr,{x,xmin,xmax},{y,ymin,ymax},pars] solves the partial differential equations eqns over a rectangular region.

ParametricNDSolveValue[eqns,expr,{x,y}∈Ω,pars] solves the partial differential equations eqns over the region Ω.

ParametricNDSolveValue[eqns,expr,{t,tmin,tmax},{x,y}∈Ω,pars] solves the time-dependent partial differential equations eqns over the region Ω.

ParametricPlot

ParametricPlot[{fx,fy},{u,umin,umax}] generates a parametric plot of a curve with x and y coordinates fx and fy as a function of u. 

ParametricPlot[{{fx,fy},{gx,gy},…},{u,umin,umax}] plots several parametric curves. 

ParametricPlot[{fx,fy},{u,umin,umax},{v,vmin,vmax}] plots a parametric region. 

ParametricPlot[{{fx,fy},{gx,gy},…},{u,umin,umax},{v,vmin,vmax}] plots several parametric regions. 

ParametricPlot[{…,w[{fx,fy}],…},…] plots the curve {fx,fy} with features defined by the symbolic wrapper w.

ParametricPlot[…,{u,v}∈reg] takes parameters {u,v} to be in the geometric region reg.

ParametricPlot3D

ParametricPlot3D[{fx,fy,fz},{u,umin,umax}] produces a three-dimensional space curve parametrized by a variable u which runs from umin to umax. 

ParametricPlot3D[{fx,fy,fz},{u,umin,umax},{v,vmin,vmax}] produces a three-dimensional surface parametrized by u and v. 

ParametricPlot3D[{{fx,fy,fz},{gx,gy,gz},…},…] plots several objects together. 

ParametricPlot3D[…,{u,v}∈reg] takes parameters {u,v} to be in the geometric region reg.

ParametricRampLayer

ParametricRampLayer[] represents a net layer that computes a leaky ReLU activation with a slope that can be learned.

ParametricRampLayer[levels] specifies the levels on which each dimension has a specific slope.

ParametricRegion

ParametricRegion[{f1,…,fn},{u1,…,um}] represents a region in n given by the points {f1,…,fn} for parameters ui∈.

ParametricRegion[{f1,…,fn},{{u1,a1,b1},…}] constrains parameters to an interval a1≤u1≤b1 etc. 

ParametricRegion[{{f1,…,fn},cond},…] constrains parameters to satisfy the condition cond.

ParentCell

ParentCell[obj] returns the CellObject that contains obj.

ParentDirectory

ParentDirectory[] gives the parent of the current working directory. 

ParentDirectory["dir"] gives the parent of the directory dir. 

ParentDirectory["dir",n] gives the directory n levels up from dir.

Parenthesize

Parenthesize[ expr, fmt, prec, group] or Parenthesize[ expr, fmt, {prec, group}] will represent expr in format fmt and parenthesize it if necessary when it is an operand to an operator of the given precedence and grouping.

Parenthesize[expr,fmt,head] infers prec and group from the operator, if any, used by the symbol head in fmt.

Parenthesize[expr,fmt,prec,group,side] or Parenthesize[expr,fmt,head,side] assume expr appears on the specified side of the operator.

ParetoDistribution

ParetoDistribution[k,α] represents a Pareto distribution with minimum value parameter k and shape parameter α.

ParetoDistribution[k,α,μ] represents a Pareto type II distribution with location parameter μ.

ParetoDistribution[k,α,γ,μ] represents a Pareto type IV distribution with shape parameter γ.

ParetoPickandsDistribution

ParetoPickandsDistribution[μ,σ,ξ] gives a Pareto–Pickands distribution with location parameter μ, scale parameter σ and shape parameter ξ.

ParetoPickandsDistribution[ξ] gives the standard Pareto–Pickands distribution with zero location and unit scale parameters.

ParkData

ParkData[entity,property] gives the value of the specified property for the park entity.

ParkData[{entity1,entity2,…},property] gives a list of property values for the specified park entities.

ParkData[entity,property,annotation] gives the specified annotation associated with the given property.

Part

expr[[i]] or Part[expr,i] gives the ith part of expr. 

expr[[-i]] counts from the end. 

expr[[i,j,…]] or Part[expr,i,j,…] is equivalent to expr[[i]][[j]]…. 

expr[[{i1,i2,…}]] gives a list of the parts i1, i2, … of expr. 

expr[[m;;n]] gives parts m through n.

expr[[m;;n;;s]] gives parts m through n in steps of s.

expr[["key"]] gives the value associated with the key "key" in an association expr.

expr[[Key[k]]] gives the value associated with an arbitrary key k in the association expr.

PartBehavior

PartBehavior is an option to Query and related functions that specifies how nonexistent parts should be resolved.

PartialCorrelationFunction

PartialCorrelationFunction[data,hspec] estimates the partial correlation function at lags hspec from data.

PartialCorrelationFunction[tproc,hspec] represents the partial correlation function at lags hspec for the time series process tproc. 

ParticleAcceleratorData

ParticleAcceleratorData[entity,property] gives the value of the specified property for the particle accelerator entity.

ParticleAcceleratorData[{entity1,entity2,…},property] gives a list of property values for the specified particle accelerator entities.

ParticleAcceleratorData[entity,property,annotation] gives the specified annotation associated with the given property.

ParticleData

ParticleData[name,"property"] gives the specified property for a subatomic particle or family of particles with the specified name. 

ParticleData[{name,q},"property"] gives the specified property for a version of the particle with charge q.

Partition

Partition[list,n] partitions list into nonoverlapping sublists of length n. 

Partition[list,n,d] generates sublists with offset d. 

Partition[list,{n1,n2,…}] partitions a nested list into blocks of size n1×n2×….

Partition[list,{n1,n2,…},{d1,d2,…}] uses offset di at level i in list. 

Partition[list,n,d,{kL,kR}] specifies that the first element of list should appear at position kL in the first sublist, and the last element of list should appear at or after position kR in the last sublist. If additional elements are needed, Partition fills them in by treating list as cyclic. 

Partition[list,n,d,{kL,kR},x] pads if necessary by repeating the element x. 

Partition[list,n,d,{kL,kR},{x1,x2,…}] pads if necessary by cyclically repeating the elements xi. 

Partition[list,n,d,{kL,kR},{}] uses no padding, and so can yield sublists of different lengths. 

Partition[list,nlist,dlist,{klistL,klistR},padlist] specifies alignments and padding in a nested list. 

PartitionGranularity

PartitionGranularity is an option for audio analysis functions that specifies the partitioning of the audio.

PartitionsP

PartitionsP[n] gives the number p(n) of unrestricted partitions of the integer n. 

PartitionsQ

PartitionsQ[n] gives the number q(n) of partitions of the integer n into distinct parts. 

PartLayer

PartLayer[i] represents a net layer that gives the ith part of the input.

PartLayer[i;;j] gives parts i through j.

PartLayer[i;;j;;k] gives parts i through j in steps of k.

PartLayer[{spec1,spec2,…}] takes part speci at level i in the input.

PartOfSpeech

PartOfSpeech["word"] returns the possible parts of speech for the specified word.

ParzenWindow

ParzenWindow[x] represents a Parzen window function of x.

PascalDistribution

PascalDistribution[n,p] represents a Pascal distribution with parameters n and p.

EventHandler

EventHandler[expr,{event1:>action1,event2:>action2,…}] displays as expr, evaluating actioni whenever "eventi" occurs in connection with expr. 

PassEventsDown

PassEventsDown is an option to EventHandler which specifies whether events handled by a particular event handler should be passed down to event handlers nested inside.

PassEventsUp

PassEventsUp is an option to EventHandler that specifies whether events handled by a particular event handler should be passed up to event handlers in outer expressions.

Paste

Paste[expr] pastes expr at the current insertion point in the input notebook. 

Paste[notebook,expr] pastes expr to the specified notebook.

Paste[] pastes the contents of the system clipboard in the input notebook. 

Paste[notebook,Automatic] pastes the contents of the system clipboard to notebook.

Path

Path is an option for Get and related functions which gives a list of directories to search in attempting to find an external file. 

PathGraph

PathGraph[{v1,v2,…}] yields a path with vertices vi and edges between vi and vi+ 1 .

PathGraph[{e1,e2,…}] yields a path with edges ej.

PathGraph[{v1,v2,…},{e1,e2,…}] yields a path with vertices vi and edges ej.

PathGraph[{…,wi[vi,…],…},{…,wj[ej,…],…}] yields a path with vertex and edge properties defined by the symbolic wrappers wk.

PathGraph[{vi->vj,…}] uses rules vi->vj to specify a path.

PathGraphQ

PathGraphQ[g] yields True if the graph g is a path and False otherwise.

Pattern

sym:obj or Pattern[sym,obj] represents the pattern object obj, assigned the name sym. 

PatternFilling

PatternFilling[obj] is a two-dimensional graphics directive specifying that obj should be used to fill faces of polygons and other filled graphics objects.

PatternFilling["name"] uses the specified pattern "name".

PatternFilling[obj,size] specifies the size of the object obj.

PatternFilling[obj,size,{dx,dy}] moves the object obj by the offset {dx,dy}.

PatternSequence

PatternSequence[p1,p2,…] is a pattern object that represents a sequence of arguments matching p1, p2, ….

PatternTest

p?test is a pattern object that stands for any expression that matches p, and on which the application of test gives True. 

PauliMatrix

PauliMatrix[k] gives the kth Pauli spin matrix σk.

PaulWavelet

PaulWavelet[] represents a Paul wavelet of order 4.

PaulWavelet[n] represents a Paul wavelet of order n.

Pause

Pause[n] pauses for at least n seconds. 

PDF

PDF[dist,x] gives the probability density function for the distribution dist evaluated at x.

PDF[dist,{x1,x2,…}] gives the multivariate probability density function for a distribution dist evaluated at {x1,x2,…}.

PDF[dist] gives the PDF as a pure function.

PeakDetect

PeakDetect[list] gives a binary list in which 1s correspond to peak positions in list.

PeakDetect[list,σ] detects peaks that survive Gaussian blurring up to scale σ.

PeakDetect[list,σ,s] detects peaks with minimum sharpness s.

PeakDetect[list,σ,s,t] detects only peaks with values greater than t.

PeakDetect[list,σ,{s,σs},{t,σt}] uses different scales for thresholding sharpness and value.

PeanoCurve

PeanoCurve[n] gives the line segments representing the nth-step Peano curve.

PearsonChiSquareTest

PearsonChiSquareTest[data] tests whether data is normally distributed using the Pearson χ2 test.

PearsonChiSquareTest[data,dist] tests whether data is distributed according to dist using the Pearson χ2 test.

PearsonChiSquareTest[data,dist,"property"] returns the value of "property".

PearsonCorrelationTest

PearsonCorrelationTest[v1,v2] tests whether the vectors v1 and v2 are linearly independent.

PearsonCorrelationTest[…,"property"] returns the value of "property".

PearsonDistribution

PearsonDistribution[a1,a0,b2,b1,b0] represents a distribution of the Pearson family with parameters a1, a0, b2, b1, and b0.

PearsonDistribution[type,a1,a0,b2,b1,b0] represents a Pearson distribution of given type. 

PercentForm

PercentForm[expr] prints with numbers in expr given as percentages.

PercentForm[expr,n] prints with approximate real numbers in expr given as percentages to n-digit precision.

PerfectNumber

PerfectNumber[n] gives the nth perfect number.

PerfectNumberQ

PerfectNumberQ[n] returns True if n is a perfect number, and False otherwise.

PerformanceGoal

PerformanceGoal is an option for various algorithmic and presentational functions that specifies what aspect of performance to try to optimize with Automatic settings for options.

Perimeter

Perimeter[reg] gives the perimeter of the two-dimensional region reg.

Perimeter[{x1,x2},{s,smin,smax},{t,tmin,tmax}] gives the perimeter of the parametrized region whose Cartesian coordinates xi are functions of s and t.

Perimeter[{x1,x2},{s,smin,smax},{t,tmin,tmax},chart] interprets the xi as coordinates in the specified coordinate chart.

PeriodicBoundaryCondition

PeriodicBoundaryCondition[u[x1,…],pred,f] represents a periodic boundary condition =u(xtarget)=u(f(xtarget)) for all xtarget on the boundary of the region given to NDSolve where pred is True.

PeriodicBoundaryCondition[a+b u[x1,…],pred,f] represents a generalized periodic boundary condition a+b u(xtarget)=u(f(xtarget)).

Periodogram

Periodogram[list] plots the squared magnitude of the discrete Fourier transform (power spectrum) of list.

Periodogram[list,n] plots the mean of power spectra of non-overlapping partitions of length n.

Periodogram[list,n,d] uses partitions with offset d.

Periodogram[list,n,d,wfun] applies a smoothing window wfun to each partition.

Periodogram[list,n,d,wfun,m] pads partitions with zeros to length m prior to the computation of the transform.

Periodogram[{list1,list2,…},n,d,wfun,m] plots power spectra of several lists.

Periodogram[audio,…] plots the power spectrum of audio.

Periodogram[video,…] plots the power spectrum of the first audio track in video.

Periodogram[{input1,input2,…},…] plots the power spectra of all inputi.

PeriodogramArray

PeriodogramArray[list] returns the squared magnitude of the discrete Fourier transform (power spectrum) of list.

PeriodogramArray[list,n] averages the power spectra of non-overlapping partitions of length n.

PeriodogramArray[list,n,d] uses partitions with offset d.

PeriodogramArray[list,n,d,wfun] applies a smoothing window wfun to each partition.

PeriodogramArray[list,n,d,wfun,m] pads partitions with zeros to length m prior to the computation of the transform.

PeriodogramArray[image,…] returns the squared power spectrum of image.

PeriodogramArray[audio,…] returns the squared power spectrum of audio.

PeriodogramArray[video,…] returns the squared power spectrum of the first audio track in video.

Permanent

Permanent[m] gives the permanent of the square matrix m. 

PermissionsGroup

PermissionsGroup["name"] represents a permissions group with the specified name, owned by the current user.

PermissionsGroup[user,"name"] represents a permissions group owned by the specified user.

PermissionsGroupMemberQ

PermissionsGroupMemberQ[group,user] returns True if user is a member of the permissions group group, and False otherwise.

PermissionsGroups

PermissionsGroups[] gives a list of permissions groups belonging to the current user.

PermissionsKeys

PermissionsKeys[] gives a list of all valid permissions keys created by the currently authenticated user.

PermutationCycles

PermutationCycles[perm] gives a disjoint cycle representation of permutation perm.

PermutationCyclesQ

PermutationCyclesQ[expr] returns True if expr is a permutation in disjoint cyclic form, and False otherwise.

PermutationGroup

PermutationGroup[{perm1,…,permn}] represents the group generated by multiplication of the permutations perm1,…,permn.

PermutationLength

PermutationLength[perm] returns the number of integers moved by the permutation perm.

PermutationList

PermutationList[perm] returns a permutation list representation of permutation perm.

PermutationList[perm,len] returns a permutation list of length len.

PermutationListQ

PermutationListQ[expr] returns True if expr is a valid permutation list and False otherwise.

PermutationMax

PermutationMax[perm] returns the largest integer moved by the permutation perm.

PermutationMin

PermutationMin[perm] returns the smallest integer moved by the permutation perm.

PermutationOrder

PermutationOrder[perm] gives the order of permutation perm.

PermutationPower

PermutationPower[perm,n] gives the nth permutation power of the permutation perm.

PermutationProduct

PermutationProduct[a,b,c] gives the product of permutations a, b, c.

PermutationReplace

PermutationReplace[expr,perm] replaces each part in expr by its image under the permutation perm.

PermutationReplace[expr,gr] returns the list of images of expr under all elements of the permutation group gr.

Permutations

Permutations[list] generates a list of all possible permutations of the elements in list. 

Permutations[list,n] gives all permutations containing at most n elements.

Permutations[list,{n}] gives all permutations containing exactly n elements.

PermutationSupport

PermutationSupport[perm] returns the support of the permutation perm.

Permute

Permute[expr,perm] permutes the positions of the elements of expr according to the permutation perm.

Permute[expr,gr] returns the list of permuted forms of expr under the elements of the permutation group gr.

PeronaMalikFilter

PeronaMalikFilter[image] applies a Perona–Malik diffusion filter to image.

PeronaMalikFilter[image,t] specifies the amount of diffusion time t to be applied. 

PeronaMalikFilter[image,t,k] uses a conductance parameter k.

PeronaMalikFilter[image,t,k,σ] applies a Gaussian regularization of width σ to the image gradient in the conductance function.

PerpendicularBisector

PerpendicularBisector[{p1,p2}] gives the perpendicular bisector of the line segment connecting p1 and p2.

PerpendicularBisector[Line[{p1,p2}]] gives the perpendicular bisector of a line segment.

PersistenceLocation

PersistenceLocation["type"] represents a persistence location of the given type.

PersistenceLocation["type",base] includes the base address for a location type that allows multiple locations.

PersistenceTime

PersistenceTime is an option for various functions that specifies when a persistent value should be treated as expired.

PersistentObject

PersistentObject["name",loc] represents a persistent object stored at persistence location loc.

PersistentObjects

PersistentObjects[] gives all persistent objects in all locations in $PersistencePath.

PersistentObjects[patt] gives all persistent objects whose names match the string pattern patt.

PersistentObjects[patt,loc] gives all matching persistent objects in persistence location loc.

PersistentObjects[patt,{loc1,…}] gives all matching persistent objects in all the loci.

PersistentSymbol

PersistentSymbol["name"] represents the persistent symbol associated with the key "name".

PersistentSymbol["name",loc] represents the persistent symbol associated with name stored in persistence location loc. 

PersistentSymbol["name",{loc1,…}] represents the persistent symbol associated with name at the first of the locations loci at which it occurs.

PersistentValue

PersistentValue["name"] represents the persistent value associated with the key "name".

PersistentValue["name",loc] represents the persistent value associated with name stored in persistence location loc. 

PersistentValue["name",{loc1,…}] represents the persistent value associated with name at the first of the locations loci at which it occurs.

PersonData

PersonData[entity,property] gives the value of the specified property for the person entity.

PersonData[{entity1,entity2,…},property] gives a list of property values for the specified person entities.

PersonData[entity,property,annotation] gives the specified annotation associated with the given property.

PERTDistribution

PERTDistribution[{min,max},c] represents a PERT distribution with range min to max and mode at c.

PERTDistribution[{min,max},c,λ] represents a modified PERT distribution with shape parameter λ.

PetersenGraph

PetersenGraph[n,k] gives the generalized Petersen graph Pn, k.

PhaseMargins

PhaseMargins[lsys] gives the phase margins of the linear time-invariant system lsys.

PhaseRange

PhaseRange is an option to BodePlot and NicholsPlot that specifies the phase range.

Pi

Pi is π, with numerical value ≃3.14159. 

Pick

Pick[list,sel] picks out those elements of list for which the corresponding element of sel is True. 

Pick[list,sel,patt] picks out those elements of list for which the corresponding element of sel matches patt. 

PIDData

PIDData[…] represents PID data generated by PIDTune function.

PIDDerivativeFilter

PIDDerivativeFilter is an option to PIDTune that controls the filtering used for derivative terms.

PIDFeedforward

PIDFeedforward is an option to PIDTune that controls the reference weights used for the feedforward filter. 

PIDTune

PIDTune[sys] gives a feedback PID controller for the system sys. 

PIDTune[sys,"carch"] gives a controller of architecture "carch" ("P", "PI", "PID", etc). 

PIDTune[sys,{"carch","trule"}] gives a controller using the tuning rule "trule". 

PIDTune[sys,…,"prop"] returns the value for the property "prop". 

Piecewise

Piecewise[{{val1,cond1},{val2,cond2},…}] represents a piecewise function with values vali in the regions defined by the conditions condi. 

Piecewise[{{val1,cond1},…},val] uses default value val if none of the condi apply. The default for val is 0. 

PiecewiseExpand

PiecewiseExpand[expr] expands nested piecewise functions in expr to give a single piecewise function. 

PiecewiseExpand[expr,assum] expands piecewise functions using assumptions. 

PiecewiseExpand[expr,assum,dom] does the expansion over the domain dom. 

PieChart

PieChart[{y1,y2,…,yn}] makes a pie chart with sector angle proportional to y1, y2, ….

PieChart[{…,wi[yi,…],…,wj[yj,…],…}] makes a pie chart with sector features defined by the symbolic wrappers wk.

PieChart[{data1,data2,…}] makes a pie chart from multiple datasets datai.

PieChart3D

PieChart3D[{y1,y2,…}] makes a 3D pie chart with sector angle proportional to y1, y2, … .

PieChart3D[{…,wi[yi,…],…,wj[yj,…],…}] makes a 3D pie chart with sector features defined by the symbolic wrappers wk.

PieChart3D[{data1,data2,…}] makes a 3D pie chart from multiple datasets datai.

PillaiTrace

PillaiTrace[m1,m2] gives Pillai's trace for the matrices m1 and m2.

PillaiTraceTest

PillaiTraceTest[m1,m2] tests whether the matrices m1 and m2 are independent.

PillaiTraceTest[…,"property"] returns the value of "property".

PingTime

PingTime[host] gives the round-trip ping time for the specified network host.

PingTime[host,n] gives a list of times for n successive pings.

Pink

Pink represents the color pink in graphics or style specifications. 

PitchRecognize

PitchRecognize[audio] recognizes the main pitch in audio, returning it as a TimeSeries object. 

PitchRecognize[audio,spec] returns the main pitch processed according to the specified spec.

PitchRecognize[video,…] recognizes the main pitch in the first audio track in video.

Pivoting

Pivoting is an option to certain matrix decomposition functions. With Pivoting -> False, no pivoting is done. With Pivoting -> True, column pivoting is carried out and the list of matrices returned is augmented by the appropriate permutation matrix.

PixelValue

PixelValue[image,ppos] gives the pixel value of image at position pos.

PixelValue[image,ppos,"type"] gives the pixel value converted to the specified type.

PixelValuePositions

PixelValuePositions[image,val] returns a list of pixel positions in image that exactly match the value val.

PixelValuePositions[image,val,d] returns all pixel positions that have values within a distance d from val.

Placed

Placed[expr,pos] represents an expression expr placed at relative position pos in a chart or other display. 

Placed[{e1,e2,…},pos] places each of the ei at a relative position specified by pos.

Placed[{e1,e2,…},pos,f] applies the function f to each of the ei before displaying it.

Placeholder

Placeholder[name] represents a placeholder labeled with name that indicates a place to type.

Placeholder[] gives the empty placeholder .

PlaceholderLayer

PlaceholderLayer[] represents a net layer whose operation is undefined.

PlaceholderLayer["tag",assoc] indicates a tag and information given by the association assoc.

PlaceholderReplace

PlaceholderReplace is an option to Paste that determines whether to replace a selection placeholder with the selected contents.

Plain

Plain represents a font that is not bold, italic, or underlined.

PlanarAngle

PlanarAngle[p->{q1,q2}] gives the angle between the half‐lines from p through q1 and q2.

PlanarAngle[{q1,p,q2}] gives the angle at p formed by the triangle with vertex points p, q1 and q2.

PlanarAngle[…,"spec"] gives the angle specified by "spec".

PlanarFaceList

PlanarFaceList[g] gives the list of faces of the planar graph g.

PlanarGraph

PlanarGraph[{e1,e2,…}] yields a planar graph with edges ej.

PlanarGraph[{v1,v2,…},{e1,e2,…}] yields a planar graph with vertices vi and edges ej.

PlanarGraph[{…,wi[vi],…},{…,wj[ej],…}] yields a planar graph with vertex and edge properties defined by the symbolic wrappers wk.

PlanarGraph[{vi->vj,…}] uses rules vi->vj to specify a planar graph.

PlanarGraphQ

PlanarGraphQ[g] yields True if g is a planar graph and False otherwise.

PlanckRadiationLaw

PlanckRadiationLaw[temperature,λ] returns the spectral radiance for the specified temperature and wavelength λ.

PlanckRadiationLaw[temperature,f] returns the spectral radiance for the specified temperature and frequency f.

PlanckRadiationLaw[temperature,property] returns the value of the property for the specified temperature.

PlanckRadiationLaw[temperature,{λ1,λ2}] returns the integrated result of the spectral radiance over the wavelength range λ1 to λ2.

PlanckRadiationLaw[temperature,{f1,f2}] returns the integrated result of the spectral radiance over the frequency range f1 to f2.

PlaneCurveData

PlaneCurveData[entity,property] gives the value of the specified property for the plane curve entity.

PlaneCurveData[{entity1,entity2,…},property] gives a list of property values for the specified plane curve entities.

PlaneCurveData[entity,property,annotation] gives the specified annotation associated with the given property.

PlanetaryMoonData

PlanetaryMoonData[entity,property] gives the value of the specified property for the moon entity of a planet or minor planet.

PlanetaryMoonData[{entity1,entity2,…},property] gives a list of property values for the specified moon entities.

PlanetaryMoonData[entity,property,annotation] gives the specified annotation associated with the property.

PlanetData

PlanetData[entity,property] gives the value of the specified property for the planet entity.

PlanetData[{entity1,entity2,…},property] gives a list of property values for the specified planet entities.

PlanetData[entity,property,annotation] gives the specified annotation associated with the property.

PlantData

PlantData[entity,property] gives the value of the specified property for the plant entity.

PlantData[{entity1,entity2,…},property] gives a list of property values for the specified plant entities.

PlantData[entity,property,annotation] gives the specified annotation associated with the property.

Play

Play[f,{t,tmin,tmax}] creates an object that plays as a sound whose amplitude is given by f as a function of time t in seconds between tmin and tmax. 

PlayRange

PlayRange is an option for Play and related functions which specifies what range of sound amplitude levels should be included. 

Plot

Plot[f,{x,xmin,xmax}] generates a plot of f as a function of x from xmin to xmax. 

Plot[{f1,f2,…},{x,xmin,xmax}] plots several functions fi. 

Plot[{…,w[fi],…},…] plots fi with features defined by the symbolic wrapper w.

Plot[…,{x}∈reg] takes the variable x to be in the geometric region reg.

Plot3D

Plot3D[f,{x,xmin,xmax},{y,ymin,ymax}] generates a three-dimensional plot of f as a function of x and y. 

Plot3D[{f1,f2,…},{x,xmin,xmax},{y,ymin,ymax}] plots several functions. 

Plot3D[{…,w[fi],…},…] plots fi with features defined by the symbolic wrapper w.

Plot3D[…,{x,y}∈reg] takes variables {x,y} to be in the geometric region reg. 

PlotDivision

PlotDivision is an option for Plot that specifies the maximum amount of subdivision to be used.

PlotJoined

PlotJoined is an option for ListPlot that specifies whether the points plotted should be joined by a line. 

PlotLabel

PlotLabel is an option for graphics functions that specifies an overall label for a plot. 

PlotLabels

PlotLabels is an option for visualization functions that specifies what labels to use for each data source.

PlotLayout

PlotLayout is an option for plotting functions that specifies the layout of multiple components in a plot.

PlotLegends

PlotLegends is an option for plot functions that specifies what legends to use. 

PlotMarkers

PlotMarkers is an option for graphics functions like ListPlot and ListLinePlot that specifies what markers to draw at the points plotted. 

PlotPoints

PlotPoints is an option for plotting functions that specifies how many initial sample points to use. 

PlotRange

PlotRange is an option for graphics functions that specifies what range of coordinates to include in a plot. 

PlotRangeClipping

PlotRangeClipping is an option for graphics functions that specifies whether graphics objects should be clipped at the edge of the region defined by PlotRange, or should be allowed to extend to the actual edge of the image. 

PlotRangePadding

PlotRangePadding is an option for graphics functions that specifies how much further axes etc. should extend beyond the range of coordinates specified by PlotRange. 

PlotRegion

PlotRegion is an option for graphics functions that specifies what region of the final display area a plot should fill. 

PlotStyle

PlotStyle is an option for plotting and related functions that specifies styles in which objects are to be drawn. 

PlotTheme

PlotTheme is an option for plotting and related functions that specifies an overall theme for visualization elements and styles. 

Pluralize

Pluralize["noun"] gives the plural form of the English word "noun".

Pluralize["noun",n] gives the inflected form of "noun" for n instances. 

Pluralize[{"singular","plural"},n] inflects using the specified forms.

Pluralize[spec,list] uses the length of list to determine the inflection to use. 

Plus

x+y+z represents a sum of terms. 

PlusMinus

PlusMinus[x] displays as ±x.

PlusMinus[x,y,…] displays as x±y±….

Pochhammer

Pochhammer[a,n] gives the Pochhammer symbol (a)n.

PodStates

PodStates is an option for WolframAlpha that determines information about the states of the pods.

PodWidth

PodWidth is an option for WolframAlpha that determines the width parameters of the content returned by the Wolfram|Alpha API.

Point

Point[p] is a graphics and geometry primitive that represents a point at p. 

Point[{p1,p2,…}] represents a collection of points. 

PointCountDistribution

PointCountDistribution[pproc,reg] represents the distribution of point counts for the point process pproc in the region reg.

PointCountDistribution[pproc,{reg1,…,regn}] represents the joint distribution of point counts in regions regi. 

PointDensity

PointDensity[pdata] estimates the point density function μ(x) from point data pdata.

PointDensity[pdata,pmethod] estimates the point density function μ(x) with the partition method pmethod.

PointDensity[bdata,…] estimates the point density function μ(x) from binned data bdata.

PointDensity[pproc,…] computes the density function μ(x) for point process pproc.

PointDensityFunction

PointDensityFunction[…] represents a function whose values give the density at a given location.

PointFigureChart

PointFigureChart[{{date1,p1},{date2,p2},…}] makes a point and figure chart with prices pi at date datei.

PointFigureChart[{"name",daterange}] makes a point and figure chart of closing prices for the financial entity "name" over the date range daterange.

PointFigureChart[{…},s,n] makes a point and figure chart with point and figure height s and n reversals.

PointLegend

PointLegend[{col1,…},{lbl1,…}] generates a legend that associates points of colors coli with labels lbli.

PointLegend[{col1,…},Automatic] generates a legend with placeholder labels for the colors coli.

PointLegend[{lbl1,…}] represents a legend with inherited colors within visualization functions.

PointLight

PointLight[col,pt] is a three-dimensional graphics directive that specifies the point light of color col at position pt to use in coloring 3D surfaces.

PointLight[col,pt,att] uses the point light with geometric attenuation att.

PointProcessEstimator

PointProcessEstimator[] is an option to EstimatedPointProcess and FindPointProcessParameters that specifies what point process parameter estimator to use. 

PointProcessFitTest

PointProcessFitTest[pdata] tests whether the point collection pdata could be modeled by a Poisson point process.

PointProcessFitTest[pdata,pproc] tests whether the point collection could be modeled by the point process pproc.

PointProcessFitTest[pdata,pproc,"property"] returns the value of "property".

PointProcessParameterAssumptions

PointProcessParameterAssumptions[proc] gives a logical expression for assumptions on parameters in the point process proc.

PointProcessParameterQ

PointProcessParameterQ[proc] yields True if proc is a valid random point process, and yields False otherwise.

PointSize

PointSize[d] is a graphics directive which specifies that points which follow are to be shown if possible as circular regions with diameter d. The diameter d is given as a fraction of the total width of the plot. 

PointStatisticFunction

PointStatisticFunction[…] represents a function whose values give the statistic of a points collection pdata at a supplied radius.

PointValuePlot

PointValuePlot[{pt1->val1,pt2->val2,…}] plots the points pti styled according to the values vali.

PointValuePlot[pts->vals] uses a collection of points pti from pts with corresponding values vali from val.

PointValuePlot[…,enc] uses the visual encoding enc to represent the values vali in the plot.

PointValuePlot[data,…] plots the locations and values from data.

PoissonConsulDistribution

PoissonConsulDistribution[μ,λ] represents a Poisson–Consul distribution with parameters μ and λ.

PoissonDistribution

PoissonDistribution[μ] represents a Poisson distribution with mean μ.

PoissonPDEComponent

PoissonPDEComponent[vars,pars] yields a Poisson PDE term ∇2{x1,…,xn}u-f with model variables vars and model parameters pars.

PoissonProcess

PoissonProcess[μ] represents a Poisson process with rate μ.

PoissonWindow

PoissonWindow[x] represents a Poisson window function of x.

PoissonWindow[x,α] uses the parameter α.

PolarAxes

PolarAxes is an option for sector charts and polar plots that specifies whether polar axes should be drawn.

PolarAxesOrigin

PolarAxesOrigin is an option for sector charts and polar plots that specifies where polar axes should be drawn.

PolarGridLines

PolarGridLines is an option for sector charts and polar plots that specifies polar grid lines.

PolarPlot

PolarPlot[r,{θ,θmin,θmax}] generates a polar plot of a curve with radius r as a function of angle θ.

PolarPlot[{r1,r2,…},{θ,θmin,θmax}] makes a polar plot of curves with radius functions r1, r2, ….

PolarTicks

PolarTicks is an option for sector charts and polar plots that specifies tick marks for polar axes.

PoleZeroMarkers

PoleZeroMarkers is an option for RootLocusPlot that specifies the markers to be drawn on the complex plane at the open-loop poles, closed-loop poles, and open-loop zeros.

PolyaAeppliDistribution

PolyaAeppliDistribution[θ,p] represents a Pólya–Aeppli distribution with shape parameters θ and p. 

PolyGamma

PolyGamma[z] gives the digamma function ψ(z). 

PolyGamma[n,z] gives the nth derivative of the digamma function ψ(n)(z). 

Polygon

Polygon[{p1,…,pn}] represents a filled polygon with points pi.

Polygon[{p1,…,pn}->{{q1,…,qm},…}] represents a polygon with holes {q1,…,qm},….

Polygon[{poly1,poly2,…}] represents a collection of polygons polyi.

Polygon[{p1,…,pn},data] represents a polygon in which coordinates given as integers i in data are taken to be pi.

PolygonalNumber

PolygonalNumber[n] gives the nth triangular number Tn.

PolygonalNumber[r,n] gives the nth r-gonal number Pn r.

PolygonAngle

PolygonAngle[poly] gives a list of angles at the vertex points of poly.

PolygonAngle[poly,p] gives the angle at the vertex point p of a polygon poly.

PolygonAngle[poly,i] gives the angle at the point pi of poly in canonical form Polygon[{p1,…,pn},data].

PolygonAngle[…,"spec"] gives the angle specified by "spec".

PolygonCoordinates

PolygonCoordinates[poly] gives a list of coordinates in the polygon poly.

PolygonDecomposition

PolygonDecomposition[poly] decomposes the polygon poly into a disjoint union of simpler polygons.

PolygonDecomposition[poly,"type"] decomposes into polygons of the specified "type".

PolygonIntersections

PolygonIntersections is an option for Graphics3D which specifies whether intersecting polygons should be left unchanged. 

Polyhedron

Polyhedron[{f1,…,fn}] represents a filled polyhedron inside the closed surfaces with polygon faces fi.

Polyhedron[{f1,…,fn}->{{g1,…,gm},…}] represents a polyhedron with voids {g1,…,gm},….

Polyhedron[{poly1,poly2,…}] represents a collection of polyhedra polyi.

Polyhedron[{p1,…,pn},data] represents a polyhedron in which coordinates given as integers i in data are taken to be pi.

PolyhedronAngle

PolyhedronAngle[poly,p] gives the solid angle at the point p and spanned by edges with common point p.

PolyhedronAngle[poly,e] gives the dihedral angle between the two faces with common edge e.

PolyhedronCoordinates

PolyhedronCoordinates[poly] gives a list of coordinates in the polyhedron poly.

PolyhedronData

PolyhedronData[poly,"property"] gives the value of the specified property for the polyhedron named poly.

PolyhedronData[poly] gives an image of the polyhedron named poly.

PolyhedronData["class"] gives a list of the polyhedra in the specified class.

PolyhedronDecomposition

PolyhedronDecomposition[poly] decomposes the polyhedron poly into a union of simpler polyhedra.

PolyhedronGenus

PolyhedronGenus[poly] gives the genus of the polyhedron poly.

PolyLog

PolyLog[n,z] gives the polylogarithm function Lin(z).

PolyLog[n,p,z] gives the Nielsen generalized polylogarithm function Sn,p(z). 

PolynomialExpressionQ

PolynomialExpressionQ[expr,x] gives True if expr is structurally a polynomial expression in x, and False otherwise.

PolynomialExpressionQ[expr,{x,y,…}] gives True if expr is structurally a polynomial expression in x,y,…, and False otherwise.

PolynomialExpressionQ[expr,{x,y,…},test] gives True if expr is structurally a polynomial expression in x,y,… with coefficients satisfying test, and False otherwise.

PolynomialExtendedGCD

PolynomialExtendedGCD[poly1,poly2,x] gives the extended GCD of poly1 and poly2 treated as univariate polynomials in x.

PolynomialExtendedGCD[poly1,poly2,x,Modulus->p] gives the extended GCD over the integers modulo the prime p.

PolynomialGCD

PolynomialGCD[poly1,poly2,…] gives the greatest common divisor of the polynomials polyi. 

PolynomialGCD[poly1,poly2,…,Modulus->p] evaluates the GCD modulo the prime p. 

PolynomialLCM

PolynomialLCM[poly1,poly2,…] gives the least common multiple of the polynomials polyi. 

PolynomialLCM[poly1,poly2,…,Modulus->p] evaluates the LCM modulo the prime p. 

PolynomialMod

PolynomialMod[poly,m] gives the polynomial poly reduced modulo m. 

PolynomialMod[poly,{m1,m2,…}] reduces modulo all of the mi. 

PolynomialQ

PolynomialQ[expr,var] yields True if expr is a polynomial in var, and yields False otherwise. 

PolynomialQ[expr,{var1,…}] tests whether expr is a polynomial in the vari. 

PolynomialQuotient

PolynomialQuotient[p,q,x] gives the quotient of p and q, treated as polynomials in x, with any remainder dropped. 

PolynomialQuotientRemainder

PolynomialQuotientRemainder[p,q,x] gives a list of the quotient and remainder of p and q, treated as polynomials in x. 

PolynomialReduce

PolynomialReduce[poly,{poly1,poly2,…},{x1,x2,…}] yields a list representing a reduction of poly in terms of the polyi. The list has the form {{a1,a2,…},b}, where b is minimal and a1 poly1+a2 poly2+…+b is exactly poly. 

PolynomialRemainder

PolynomialRemainder[p,q,x] gives the remainder from dividing p by q, treated as polynomials in x. 

PoolingLayer

PoolingLayer[sz] represents a pooling net layer using kernels of size sz.

PoolingLayer[{w}] represents a layer performing one-dimensional pooling with kernels of size w.

PoolingLayer[{h,w}] represents a layer performing two-dimensional pooling with kernels of size h×w.

PoolingLayer[{h,w,d}] represents a layer performing three-dimensional pooling with kernels of size h×w×d.

PoolingLayer[kernel,stride] represents a layer that uses stride as the step size between kernel applications.

PoolingLayer[kernel,opts] includes options for other pooling methods, padding and other parameters.

PopupWindow

PopupWindow[expr,contents] displays as expr, but pops up a window containing contents when clicked.

Position

Position[expr,pattern] gives a list of the positions at which objects matching pattern appear in expr. 

Position[expr,pattern,levelspec] finds only objects that appear on levels specified by levelspec. 

Position[expr,pattern,levelspec,n] gives the positions of the first n objects found. 

Position[pattern] represents an operator form of Position that can be applied to an expression.

PositionIndex

PositionIndex[list] gives an association between unique elements in list and the positions at which they occur.

PositionIndex[assoc] gives an association whose keys are the distinct values in assoc, and whose values are lists of the keys with which they are associated.

Positive

Positive[x] gives True if x is a positive number. 

PositiveDefiniteMatrixQ

PositiveDefiniteMatrixQ[m] gives True if m is explicitly positive definite, and False otherwise. 

PositiveIntegers

PositiveIntegers represents the domain of strictly positive integers, as in x∈PositiveIntegers. 

PositivelyOrientedPoints

PositivelyOrientedPoints[{p1,p2,p3,…,pd+1}] tests whether the sequence of points p1,p2,p3,…,pd+1 is positively oriented.

PositiveRationals

PositiveRationals represents the domain of strictly positive rational numbers, as in x∈PositiveRationals. 

PositiveReals

PositiveReals represents the domain of strictly positive real numbers.

PositiveSemidefiniteMatrixQ

PositiveSemidefiniteMatrixQ[m] gives True if m is explicitly positive semidefinite, and False otherwise. 

PossibleZeroQ

PossibleZeroQ[expr] gives True if basic symbolic and numerical methods suggest that expr has value zero, and gives False otherwise. 

Postfix

Postfix[f[expr]] prints with f[expr] given in default postfix form: expr//f. 

Postfix[f[expr],h] prints as exprh. 

Power

x^y gives x to the power y.

PowerDistribution

PowerDistribution[k,a] represents a power distribution with domain parameter k and shape parameter a.

PowerExpand

PowerExpand[expr] expands all powers of products and powers. 

PowerExpand[expr,{x1,x2,…}] expands only with respect to the variables xi.

PowerMod

PowerMod[a,b,m] gives ab mod m. 

PowerMod[a,-1,m] finds the modular inverse of a modulo m.

PowerMod[a,1/r,m] finds a modular rth root of a.

PowerModList

PowerModList[a,s/r,m] gives a list of all x modulo m for which xr≡as mod m.

PowerRange

PowerRange[b] generates the list {1,10,100,…,max}, where max is the largest power of 10 that does not exceed b.

PowerRange[a,b] generates the list {a,10a,100a,…,max}, with successive elements increasing by factors of 10. 

PowerRange[a,b,r] uses factors of r instead of 10.

PowerSpectralDensity

PowerSpectralDensity[data,ω] estimates the power spectral density for data.

PowerSpectralDensity[data,ω,sspec] estimates the power spectral density for data with smoothing specification sspec.

PowerSpectralDensity[tproc,ω] represents the power spectral density of a time series process tproc.

PowerSymmetricPolynomial

PowerSymmetricPolynomial[r] represents a formal power symmetric polynomial with exponent r.

PowerSymmetricPolynomial[{r1,r2,…}] represents a multivariate formal power symmetric polynomial with exponents r1, r2, ….

PowerSymmetricPolynomial[rspec,data] gives the power symmetric polynomial in data. 

Precedence

Precedence[sym] returns the precedence of the output operator associated to the symbol sym.

Precedence[boxes,fmt] returns the precedence of the operator of used in the typeset expression boxes, assuming it was typeset in the format fmt.

PrecedenceForm

PrecedenceForm[expr,prec] prints with expr parenthesized as it would be if it contained an operator with precedence prec. 

Precedes

Precedes[x,y,…] displays as x≺y≺….

PrecedesEqual

PrecedesEqual[x,y,…] displays as x⪯y⪯….

PrecedesSlantEqual

PrecedesSlantEqual[x,y,…] displays as x≼y≼….

PrecedesTilde

PrecedesTilde[x,y,…] displays as x≾y≾….

Precision

Precision[x] gives the effective number of digits of precision in the number x. 

PrecisionGoal

PrecisionGoal is an option for various numerical operations which specifies how many effective digits of precision should be sought in the final result. 

PreDecrement

--x decreases the value of x by 1, returning the new value of x. 

Predict

Predict[{in1->out1,in2->out2,…}] generates a PredictorFunction that attempts to predict outi from the example ini.

Predict[data,input] attempts to predict the output associated with input from the training examples given.

Predict[data,input,prop] computes the specified property prop relative to the prediction.

PredictorFunction

PredictorFunction[…] represents a function generated by Predict that predicts numerical values from data.

PredictorInformation

PredictorInformation[predictor] generates a report giving information on the predictor function predictor.

PredictorInformation[predictor,prop] gives information for predictor associated with property prop.

PredictorMeasurements

PredictorMeasurements[predictor,testset,prop] gives measurements associated with the property prop when predictor is evaluated on testset.

PredictorMeasurements[predictor,testset] yields a measurement report that can be applied to any property.

PredictorMeasurements[data,…] use predictions data instead of a predictor.

PredictorMeasurements[…,{prop1,prop2,…}] gives properties prop1, prop2, etc.

PredictorMeasurementsObject

PredictorMeasurementsObject[…] represents an object generated by PredictorMeasurements that can be applied to properties.

PreemptProtect

PreemptProtect[expr] evaluates expr, without any interruption from preemptive evaluations.

PreferencesPath

PreferencesPath is a global option that specifies which directories are searched for user-specific settings when the Wolfram System is started.

Prefix

Prefix[f[expr]] prints with f[expr] given in default prefix form: f@expr. 

Prefix[f[expr],h] prints as hexpr. 

PreIncrement

++x increases the value of x by 1, returning the new value of x. 

Prepend

Prepend[expr,elem] gives expr with elem prepended. 

Prepend[elem] represents an operator form of Prepend that can be applied to an expression.

PrependLayer

PrependLayer[] represents a net layer that takes an input array and prepends another array to it.

PrependTo

PrependTo[x,elem] prepends elem to the value of x, and resets x to the result. 

PreprocessingRules

PreprocessingRules is an option that specifies how the input should be preprocessed.

PreserveColor

PreserveColor is an option for ImageRestyle and related functions that specifies whether to preserve colors in the original image.

PreserveImageOptions

PreserveImageOptions is an option to graphics and related functions that specifies whether image size and certain other options should be preserved from the previous version of a graphic if the graphic is replaced by a new one in output.

PreviousDate

PreviousDate[gran] gives the previously occurring date of the specified granularity type gran.

PreviousDate[daytype] gives the previous day corresponding to the specified daytype.

PreviousDate[date,gran] gives the previous date of the given granularity relative to the specified date.

PriceGraphDistribution

PriceGraphDistribution[n,k,a] represents a de Solla Price graph distribution for n-vertex graphs where a new vertex with k edges is added at each step, using attractiveness parameter a.

Prime

Prime[n] gives the nth prime number pn.

PrimeNu

PrimeNu[n] gives the number of distinct primes ν(n) in n.

PrimeOmega

PrimeOmega[n] gives the number of prime factors counting multiplicities Ω(n) in n.

PrimePi

PrimePi[x] gives the number of primes π(x) less than or equal to x.

PrimePowerQ

PrimePowerQ[expr] yields True if expr is a power of a prime number, and yields False otherwise. 

PrimeQ

PrimeQ[n] yields True if n is a prime number, and yields False otherwise. 

Primes

Primes represents the domain of prime numbers, as in x∈Primes. 

PrimeZetaP

PrimeZetaP[s] gives prime zeta function P(s).

PrimitivePolynomialQ

PrimitivePolynomialQ[poly,p] tests whether poly is a primitive polynomial modulo a prime p.

PrimitiveRoot

PrimitiveRoot[n] gives a primitive root of n.

PrimitiveRoot[n,k] gives the smallest primitive root of n greater than or equal to k.

PrimitiveRootList

PrimitiveRootList[n] gives a list of primitive roots of n.

PrincipalComponents

PrincipalComponents[matrix] transforms elements of matrix into unscaled principal components.

PrincipalValue

PrincipalValue is an option for Integrate that specifies whether the Cauchy principal value should be found for a definite integral. 

Print

Print[expr] prints expr as output. 

PrintableASCIIQ

PrintableASCIIQ[string] yields True if the string contains only printable ASCII characters, and yields False otherwise. 

PrintAction

PrintAction is an option for notebooks that specifies the action taken when a Print[] command is evaluated by the kernel.

PrintingCopies

PrintingCopies is an option for notebooks that specifies the number of copies of a notebook printed when a print command is given.

PrintingOptions

PrintingOptions is an option that specifies settings for printing.

PrintingPageRange

PrintingPageRange is an option for notebooks that specifies the range of pages of a notebook to be printed.

PrintingStartingPageNumber

PrintingStartingPageNumber is an option for notebooks that specifies what number to assign to the first page of a notebook when printed.

PrintingStyleEnvironment

PrintingStyleEnvironment is an option for notebooks that specifies the style environment to be used in printing the notebook on paper. 

Printout3D

Printout3D[model] prints out the 3D model using a 3D print previewer.

Printout3D[model,service] prints out the 3D model using the specified 3D printing service.

Printout3D[model,"file.ext"] saves a print-ready form of the model to a file in the format indicated by the file extension ext.

Printout3DPreviewer

Printout3DPreviewer is an option for Printout3D that specifies a previewer for generating outputs to print.

PrintPrecision

PrintPrecision is an option for selections that specifies the maximum number of digits used for displaying a machine-precision number.

Prism

Prism[{p1,…,p6}] represents a filled prism connecting the triangles {p1,p2,p3} and {p4,p5,p6}.

PrivateEvaluationOptions

PrivateEvaluationOptions is an option for selections that specifies settings for evaluation-related suboptions.

PrivateFontOptions

PrivateFontOptions is an option for selections that specifies settings for various font suboptions.

PrivateKey

PrivateKey[assoc] represents the private part of a key pair for a public-key cryptographic system.

Probability

Probability[pred,xdist] gives the probability for an event that satisfies the predicate pred under the assumption that x follows the probability distribution dist.

Probability[pred,xdata] gives the probability for an event that satisfies the predicate pred under the assumption that x follows the probability distribution given by data.

Probability[pred,{x1,x2,…}dist] gives the probability that an event satisfies pred under the assumption that {x1,x2,…} follows the multivariate distribution dist.

Probability[pred,{x1dist1,x2dist2,…}] gives the probability that an event satisfies pred under the assumption that x1, x2, … are independent and follow the distributions dist1, dist2, ….

Probability[pred1pred2,…] gives the conditional probability of pred1 given pred2.

ProbabilityDistribution

ProbabilityDistribution[pdf,{x,xmin,xmax}] represents the continuous distribution with PDF pdf in the variable x where the pdf is taken to be zero for x<xmin and x>xmax.

ProbabilityDistribution[pdf,{x,xmin,xmax,1}] represents the discrete distribution with PDF pdf in the variable x where the pdf is taken to be zero for x<xmin and x>xmax.

ProbabilityDistribution[pdf,{x,…},{y,…},…] represents a multivariate distribution with PDF pdf in the variables x, y, …, etc. 

ProbabilityDistribution[{"CDF",cdf},…] represents a probability distribution with CDF given by cdf. 

ProbabilityDistribution[{"SF",sf},…] represents a probability distribution with survival function given by sf. 

ProbabilityDistribution[{"HF",hf},…] represents a probability distribution with hazard function given by hf. 

ProbabilityPlot

ProbabilityPlot[list] generates a plot of the CDF of list against the CDF of a normal distribution.

ProbabilityPlot[dist] generates a plot of the CDF of the distribution dist against the CDF of a normal distribution.

ProbabilityPlot[data,rdata] generates a plot of the CDF of data against the CDF of rdata.

ProbabilityPlot[data,rdist] generates a plot of the CDF of data against the CDF of symbolic distribution rdist.

ProbabilityPlot[{data1,data2,…},ref] generates a plot of the CDF of datai against the CDF of a reference distribution ref.

ProbabilityScalePlot

ProbabilityScalePlot[{x1,x2,…}] generates a normal probability plot of the samples xi. 

ProbabilityScalePlot[{x1,x2,…},"dist"] generates a probability plot scaled for the distribution "dist".

ProbabilityScalePlot[{data1,data2,…},"dist"] generates several scaled probability plots for data1, data2, ….

ProcessConnection

ProcessConnection[proc, "stream"] returns the stream object for a given stream.

ProcessDirectory

ProcessDirectory is an option specifying the initial working directory to use when executing a process in functions like StartProcess and RunProcess.

ProcessEnvironment

ProcessEnvironment is an option specifying the initial settings of environment variables to use when executing a process in functions like StartProcess and RunProcess.

Processes

Processes[] returns a list of currently running external processes, started in this Wolfram Language session.

ProcessEstimator

ProcessEstimator is an option to EstimatedProcess and FindProcessParameters that specifies what process parameter estimator to use. 

ProcessInformation

ProcessInformation[proc] gives information about an external process proc.

ProcessInformation[proc, "prop"] gives information about the property "prop".

ProcessObject

ProcessObject[...] is an object that represents a runnable external process.

ProcessParameterAssumptions

ProcessParameterAssumptions[proc] gives a logical expression for assumptions on parameters in the random process proc.

ProcessParameterQ

ProcessParameterQ[proc] yields True if proc is a valid random process, and yields False otherwise.

ProcessStatus

ProcessStatus[proc] gives the current status of the external process represented by the ProcessObject proc.

ProcessStatus[proc, "status"] returns True if the process has the status given, and returns False otherwise.

ProductDistribution

ProductDistribution[dist1,dist2,…] represents the joint distribution with independent component distributions dist1, dist2, ….

ProductLog

ProductLog[z] gives the principal solution for w in zwew. 

ProductLog[k,z] gives the kth solution. 

ProgressReporting

ProgressReporting is an option for various algorithmic functions that specifies whether to report the progress of the computation.

Projection

Projection[u,v] finds the projection of the vector u onto the vector v.

Projection[u,v,f] finds projections with respect to the inner product function f.

Prolog

Prolog is an option for graphics functions which gives a list of graphics primitives to be rendered before the main part of the graphics is rendered. 

PromptForm

PromptForm[prompt, expr] prints as an output prompt and expression.

ProofObject

ProofObject[…] represents a proof object generated by FindEquationalProof.

Properties

Properties is an option that allows specification of properties to objects and items of objects.

Property

Property[item,name->value] associates the property name->value with item.

PropertyList

PropertyList[{obj,itemspec}] lists the properties available for itemspec in obj.

PropertyValue

PropertyValue[{obj,item},name] gives the property value associated with name for item in obj.

PropertyValue[{obj,itemspec},name] gives the property values associated with name for items indicated by itemspec in obj.

PropertyValue[…,{name1,name2,…}] gives a list of property values associated with name1, name2, etc.

Proportion

Proportion[x,y,…] displays as x∷y∷….

Proportional

Proportional[x,y,…] displays as x∝y∝….

Protect

Protect[s1,s2,…] sets the attribute Protected for the symbols si.

Protect[patt1,patt2,…] protects all symbols whose names textually match any of the arbitrary string patterns patti.

Protect[{spec1,spec2,…}] protects any symbols that are equal to or whose names match any of the speci.

Protected

Protected is an attribute that prevents any values associated with a symbol from being modified. 

ProteinData

ProteinData[entity] gives the reference amino acid sequence for the protein entity.

ProteinData[entity,property] gives the value of the specified property for the protein entity.

ProteinData[entity,property,annotation] gives the specified annotation associated with the given property.

Pruning

Pruning[image] removes the outermost branches of thin objects in image by setting their values to black.

Pruning[image,n] removes branches that are at most n pixels long.

Pruning[image,{n}] removes n pixels from each branch.

Pruning[image,n,t] treats values above t as foreground.

PseudoInverse

PseudoInverse[m] finds the pseudoinverse of a rectangular matrix. 

PsychrometricPropertyData

PsychrometricPropertyData[spec] returns the psychrometric properties of moist air for the specified parameters.

PsychrometricPropertyData[spec,property] returns the specified property for the given parameters.

PublicKey

PublicKey[assoc] represents the public part of a key pair for a public-key cryptographic system.

PublicKey[PrivateKey[…]] creates a matching public key for the given private key.

PublisherID

PublisherID is an option for ResourceSubmit that specifies the ID used to submit a resource for publication in the resource system.

PulsarData

PulsarData[entity,property] gives the value of the specified property for the pulsar entity.

PulsarData[{entity1,entity2,…},property] gives a list of property values for the specified pulsar entities.

PulsarData[entity,property,annotation] gives the specified annotation associated with the given property.

PunctuationCharacter

PunctuationCharacter represents a punctuation character in StringExpression.

Purple

Purple represents the color purple in graphics or style specifications. 

Put

expr>>filename writes expr to a file. 

Put[expr1,expr2,…,"filename"] writes a sequence of expressions expri to a file. 

Put["filename"] creates an empty file with the specified name.

PutAppend

expr>>>filename appends expr to a file. 

PutAppend[expr1,expr2,…,"filename"] appends a sequence of expressions expri to a file. 

Pyramid

Pyramid[{p1,…,p5}] represents a filled pyramid with base {p1,…,p4} and top p5.

QBinomial

QBinomial[n,m,q] gives the q-binomial coefficient (�)q.

QFactorial

QFactorial[n,q] gives the q-factorial [n]q!.

QGamma

QGamma[z,q] gives the q-gamma function Γq (z).

QHypergeometricPFQ

QHypergeometricPFQ[{a1,…,ar},{b1,…,bs},q,z] gives the basic hypergeometric series rϕs(a;b;q;z).

QnDispersion

QnDispersion[list] gives the Qn statistic of the elements in list.

QnDispersion[list,c] gives the Qn statistic with a scaling factor c.

QPochhammer

QPochhammer[a,q,n] gives the q-Pochhammer symbol (a;q)n.

QPochhammer[a,q] gives the q-Pochhammer symbol (a;q)∞.

QPochhammer[q] gives the q-Pochhammer symbol (q;q)∞.

QPolyGamma

QPolyGamma[z,q] gives the q-digamma function ψq(z).

QPolyGamma[n,z,q] gives the nth derivative of the q-digamma function ψq(n)(z).

QRDecomposition

QRDecomposition[m] yields the QR decomposition for a numerical matrix m. The result is a list {q,r}, where q is a unitary matrix and r is an upper‐triangular matrix. 

QuadraticIrrationalQ

QuadraticIrrationalQ[x] gives True if x is a quadratic irrational and False otherwise.

QuadraticOptimization

QuadraticOptimization[f,cons,vars] finds values of variables vars that minimize the quadratic objective f subject to linear constraints cons.

QuadraticOptimization[{q,c},{a,b}] finds a vector x that minimizes the quadratic objective 1/2x.q.x+c.x subject to the linear inequality constraints a.x+b⪰0. 

QuadraticOptimization[{q,c},{a,b},{aeq,beq}] includes the linear equality constraints aeq.x+beq0.

QuadraticOptimization[{q,c},…,{dom1,dom2,…}] takes xi to be in the domain domi, where domi is Integers or Reals.

QuadraticOptimization[…,"prop"] specifies what solution property "prop" should be returned. 

Quantile

Quantile[data,p] gives the estimate of the pth quantile q&^p of data. 

Quantile[data,{p1,p2,…}] gives a list of quantiles p1,p2,…. 

Quantile[data,p,{{a,b},{c,d}}] uses the quantile definition specified by parameters a, b, c, d. 

Quantile[dist,p] gives a quantile of the distribution dist.

QuantilePlot

QuantilePlot[list] generates a plot of quantiles of list against the quantiles of a normal distribution.

QuantilePlot[dist] generates a plot of quantiles of the distribution dist against the quantiles of a normal distribution.

QuantilePlot[data,rdata] generates a plot of the quantiles of data against the quantiles of rdata.

QuantilePlot[data,rdist] generates a plot of the quantiles of data against the quantiles of a symbolic distribution rdist.

QuantilePlot[{data1,data2,…},ref] generates a plot of quantiles of datai against the quantiles of a reference distribution ref.

Quantity

Quantity[magnitude,unit] represents a quantity with size magnitude and unit specified by unit.

Quantity[unit] assumes the magnitude of the specified unit to be 1.

QuantityArray

QuantityArray[mags,unit] represents an array of quantities with magnitudes mags and common unit.

QuantityArray[mags,{unit1,unit2,…}] represents an array of lists of quantities with units {unit1,unit2,…}.

QuantityArray[quants] converts an array of Quantity objects into a single QuantityArray object.

QuantityDistribution

QuantityDistribution[dist,unit] represents a distribution dist of quantities with unit specified by unit.

QuantityDistribution[dist,{unit1,unit2,…}] represents a multivariate distribution with units {unit1,unit2,…}.

QuantityForm

QuantityForm[expr,form] prints expr with all Quantity expressions using the specified unit display form form.

QuantityForm[expr,{forms}] prints expr using the appropriate combination of the specified unit display forms forms.

QuantityMagnitude

QuantityMagnitude[quantity] gives the amount of the specified quantity.

QuantityMagnitude[quantity,unit] gives the value corresponding to quantity when converted to unit.

QuantityQ

QuantityQ[expr] gives True if expr is a Quantity with valid arguments, and False otherwise.

QuantityQ[expr,dims] gives True if expr is a Quantity with physical dimensions dims, and False otherwise.

QuantityUnit

QuantityUnit[quantity] returns the unit associated with the specified quantity.

QuantityVariable

QuantityVariable[var,"pq"] represents a variable with the label var and the corresponding physical quantity "pq".

QuantityVariable["pq"] represents the unlabeled physical quantity "pq".

QuantityVariableCanonicalUnit

QuantityVariableCanonicalUnit[quantityvariable] returns the canonical unit associated with the specified quantityvariable.

QuantityVariableDimensions

QuantityVariableDimensions[quantityvariable] returns a list of base dimensions associated with the specified quantityvariable.

QuantityVariableIdentifier

QuantityVariableIdentifier[quantityvariable] returns the identifier associated with the specified quantityvariable.

QuantityVariablePhysicalQuantity

QuantityVariablePhysicalQuantity[var] returns the physical quantity associated with the quantity variable var.

QuantityVariablePhysicalQuantity[var,type] returns the physical quantity using the format type.

Quartics

Quartics is an option for functions that involve solving algebraic equations that specifies whether explicit forms for solutions to quartic equations should be given.

QuartileDeviation

QuartileDeviation[data] gives the quartile deviation or semi-interquartile range of the elements in data. 

QuartileDeviation[data,{{a,b},{c,d}}] uses the quantile definition specified by parameters a, b, c, d.

QuartileDeviation[dist] gives the quartile deviation or semi-interquartile range of the distribution dist.

Quartiles

Quartiles[data] gives the {q&^1/4,q&^2/4,q&^3/4} quantile estimates of the elements in data.

Quartiles[data,{{a,b},{c,d}}] uses the quantile definition specified by parameters a, b, c, d. 

Quartiles[dist] gives the {q1/4,q2/4,q3/4} quantiles of the distribution dist.

QuartileSkewness

QuartileSkewness[data] gives the coefficient of quartile skewness for the elements in list.

QuartileSkewness[data,{{a,b},{c,d}}] uses the quantile definition specified by parameters a, b, c, d.

QuartileSkewness[dist] gives the coefficient of quartile skewness for the distribution dist.

Query

Query[operator1,operator2,…] represents a query that can be applied to a Dataset object, in which the successive operatori are applied at successively deeper levels. 

QuestionInterface

QuestionInterface[type,<|p1->s1,p2->s2,…|>] defines an interface for a QuestionObject using the given type and properties pi with settings si.

QuestionObject

QuestionObject[q,assess] represents the question q and the corresponding assessment assess.

QuestionObject[assess] derives a question from the assessment.

QueueingNetworkProcess

QueueingNetworkProcess[γ,r,μ,c] represents an open (Jackson) queueing network process with arrival vector γ, routing probability matrix r, service vector μ, and service channel vector c. 

QueueingNetworkProcess[γ,r,μ,c,k] represents a closed (Gordon–Newell) queueing network process with k jobs in the system.

QueueingProcess

QueueingProcess[λ,μ] represents an M/M/1 queue with arrival rate λ and service rate μ.

QueueingProcess[λ,sdist] represents an M/G/1 queue with arrival rate λ and service distribution sdist.

QueueingProcess[adist,μ] represents a G/M/1 queue with arrival distribution adist and service rate μ.

QueueingProcess[adist,sdist] represents a G/G/1 queue with arrival distribution adist and service distribution sdist.

QueueingProcess[…,…,c] represents a queueing process with c service channels.

QueueingProcess[…,…,c,k] represents a queueing process with system capacity k.

QueueingProcess[…,…,c,k,x0] represents a queueing process with initial state x0.

Quiet

Quiet[expr] evaluates expr "quietly", without actually outputting any messages generated.

Quiet[expr,{s1::t1,s2::t2,…}] quietens only the specified messages during the evaluation of expr.

Quiet[expr,"name"] quietens only the named group of messages.

QuietEcho

QuietEcho[expr] evaluates expr without letting Echo and related functions inside expr print any result.

Quit

Quit[] terminates a Wolfram Language kernel session. 

Quotient

Quotient[m,n] gives the integer quotient of m and n. 

Quotient[m,n,d] uses an offset d. 

QuotientRemainder

QuotientRemainder[m,n] gives a list of the quotient and remainder from division of m by n.

RadialAxisPlot

RadialAxisPlot[{y1,y2,…,yn}] generates a radial axis plot where the yi are displayed on radial axes equally spaced around the origin.

RadialAxisPlot[{data1,data2,…}] plots several datasets datai on the axes.

RadialGradientFilling

RadialGradientFilling[{col1,col2,…,coln}] is a two-dimensional graphics directive specifying that faces of polygons and other filled graphics objects are to be drawn using concentric circles of colors coli.

RadialGradientFilling[{r1,r2,…,rn}->{col1,col2,…,coln}] uses the colors coli at radii ri.

RadialGradientFilling[{r1,r2,…,rn}->{col1,col2,…,coln},{x,y}] radiates from the center point {x,y}.

RadialGradientFilling[{r1,r2,…,rn}->{col1,col2,…,coln},{{x,y},{r1,r2}}] radiates from the center point {x,y} in concentric axis-aligned ellipsoids with semiaxes length proportional to ri.

RadialGradientFilling[{r1,r2,…,rn}->{col1,col2,…,coln},{{x,y},{r1,r2}},padding] uses the specified padding when drawing beyond the boundary radii r1 and rn.

RadialGradientImage

RadialGradientImage[gcol] returns an image with values radially changing from center to corners based on gradient color gcol.

RadialGradientImage[{pos1,pos2}->gcol] returns an image where the gradient starts at pos1 and ends at pos2.

RadialGradientImage[…,size] returns a radial gradient image of the specified size.

RadialGradientImage[…,size,"type"] gives an image converted to the specified type.

RadialityCentrality

RadialityCentrality[g] gives a list of radiality centralities for the vertices in the graph g.

RadialityCentrality[g,"In"] gives a list of in-centralities for a directed graph g.

RadialityCentrality[g,"Out"] gives a list of out-centralities for a directed graph g.

RadialityCentrality[{v->w,…},…] uses rules v->w to specify the graph g.

Radon

Radon[image] gives an image representing the discrete Radon transform of image.

Radon[image,{w,h}] specifies the width w and the height h of the resulting image.

Radon[image,{w,h},{θ1,θ2}] computes the Radon transform only for angles from θ1 to θ2.

RadonTransform

RadonTransform[expr,{x,y},{p,ϕ}] gives the Radon transform of expr.

RamanujanTau

RamanujanTau[n] gives the Ramanujan τ function τ(n).

RamanujanTauL

RamanujanTauL[s] gives the Ramanujan tau Dirichlet L-function L(s).

RamanujanTauTheta

RamanujanTauTheta[t] gives the Ramanujan tau theta function θ(t).

RamanujanTauZ

RamanujanTauZ[t] gives the Ramanujan tau Z-function Z(t).

Ramp

Ramp[x] gives x if x≥0 and 0 otherwise.

Random

Random[] gives a uniformly distributed pseudorandom Real in the range 0 to 1. 

Random[type,range] gives a pseudorandom number of the specified type, lying in the specified range. Possible types are: Integer, Real and Complex. The default range is 0 to 1. You can give the range {min,max} explicitly; a range specification of max is equivalent to {0,max}. 

RandomArrayLayer

RandomArrayLayer[dist] represents a net layer that has no input and produces a random array from the univariate distribution dist.

RandomArrayLayer[dfunc] uses the univariate distribution dfunc[input] for each input value.

RandomChoice

RandomChoice[{e1,e2,…}] gives a pseudorandom choice of one of the ei. 

RandomChoice[list,n] gives a list of n pseudorandom choices. 

RandomChoice[list,{n1,n2,…}] gives an n1×n2×… array of pseudorandom choices. 

RandomChoice[{w1,w2,…}->{e1,e2,…}] gives a pseudorandom choice weighted by the wi. 

RandomChoice[wlist->elist,n] gives a list of n weighted choices.

RandomChoice[wlist->elist,{n1,n2,…}] gives an n1×n2×… array of weighted choices.

RandomColor

RandomColor[] gives a pseudorandom color directive in the RGBColor space.

RandomColor[n] gives n pseudorandom colors.

RandomColor[model] gives a color from the specified model.

RandomColor[model,n] gives n colors.

RandomColor[model,{n1,n2,…}] gives an array of colors.

RandomComplex

RandomComplex[] gives a pseudorandom complex number with real and imaginary parts in the range 0 to 1.

RandomComplex[{zmin,zmax}] gives a pseudorandom complex number in the rectangle with corners given by the complex numbers zmin and zmax.

RandomComplex[zmax] gives a pseudorandom complex number in the rectangle whose corners are the origin and zmax.

RandomComplex[range,n] gives a list of n pseudorandom complex numbers.

RandomComplex[range,{n1,n2,…}] gives an n1×n2×… array of pseudorandom complex numbers.

RandomEntity

RandomEntity[spec] gives a pseudorandom entity with a type determined by the specification spec.

RandomEntity[spec,n] gives a list of n pseudorandom entities.

RandomFunction

RandomFunction[proc,{tmin,tmax}] generates a pseudorandom function from the process proc from tmin to tmax. 

RandomFunction[proc,{tmin,tmax,dt}] generates a pseudorandom function from tmin to tmax in steps of dt.

RandomFunction[proc,…, n] generates an ensemble of n pseudorandom functions. 

RandomGeneratorState

RandomGeneratorState[…] gives a representation of the internal state of a pseudorandom generator.

RandomGeoPosition

RandomGeoPosition[] gives a pseudorandom geo position uniformly distributed on the surface of the Earth.

RandomGeoPosition[{{latmin,lonmin},{latmax,lonmax}}] gives a pseudorandom geo position uniformly distributed in the given geo bounding box. 

RandomGeoPosition[g] gives a pseudorandom geo position uniformly distributed in the geo region g.

RandomGeoPosition[g,n] gives a list of n pseudorandom geo positions uniformly distributed in the geo region g.

RandomGeoPosition[g,{n1,n2,…}] gives an n1× n2×… pseudorandom geo position array.

RandomGraph

RandomGraph[{n,m}] gives a pseudorandom graph with n vertices and m edges.

RandomGraph[{n,m},k] gives a list of k pseudorandom graphs.

RandomGraph[gdist,…] samples from the random graph distribution gdist.

RandomImage

RandomImage[max] gives an image with pseudorandom pixel values in the range 0 to max.

RandomImage[{min,max}] generates pseudorandom pixel values in the range min to max.

RandomImage[dist] generates pixel values using a symbolic distribution dist.

RandomImage[…,size] generates a random image of the specified size.

RandomImage[…,size,"type"] gives an image converted to the specified type.

RandomInstance

RandomInstance[expr] finds a random instance of an expression such as a geometric scene.

RandomInstance[expr] finds a random instance of an expression such as a geometric scene or biomolecular sequence.

RandomInstance[expr,n] finds n instances.

RandomInteger

RandomInteger[{imin,imax}] gives a pseudorandom integer in the range {imin,imax}. 

RandomInteger[imax] gives a pseudorandom integer in the range {0,…,imax}. 

RandomInteger[] pseudorandomly gives 0 or 1. 

RandomInteger[range,n] gives a list of n pseudorandom integers. 

RandomInteger[range,{n1,n2,…}] gives an n1×n2×… array of pseudorandom integers. 

RandomPermutation

RandomPermutation[gr] gives a pseudorandom permutation in the permutation group gr.

RandomPermutation[gr,n] gives a list of n pseudorandom permutations in the permutation group gr.

RandomPoint

RandomPoint[reg] gives a pseudorandom point uniformly distributed in the region reg.

RandomPoint[reg,n] gives a list of n pseudorandom points uniformly distributed in the region reg.

RandomPoint[reg,{n1,n2,…}] gives an n1× n2×… array of pseudorandom points.

RandomPoint[reg,…,{{xmin,xmax},…}] restricts to the bounds [xmin,xmax]×⋯.

RandomPointConfiguration

RandomPointConfiguration[pproc,reg] generates a pseudorandom spatial point configuration from the spatial point process pproc in the observation region reg. 

RandomPointConfiguration[pproc,reg, n] generates an ensemble of n spatial point configurations. 

RandomPolygon

RandomPolygon[n] gives a pseudorandom simple polygon with n vertex points.

RandomPolygon[spec] gives a pseudorandom polygon with the specified specification spec.

RandomPolygon[spec,k] gives a list of k pseudorandom polygons.

RandomPolygon[d->spec,…] gives a pseudorandom polygon in dimension d.

RandomPolyhedron

RandomPolyhedron[spec] gives a pseudorandom polyhedron with the specified specification spec.

RandomPolyhedron[spec,k] gives a list of k pseudorandom polyhedra.

RandomPrime

RandomPrime[{imin,imax}] gives a pseudorandom prime number in the range imin to imax.

RandomPrime[imax] gives a pseudorandom prime number in the range 2 to imax.

RandomPrime[range,n] gives a list of n pseudorandom primes.

RandomReal

RandomReal[] gives a pseudorandom real number in the range 0 to 1. 

RandomReal[{xmin,xmax}] gives a pseudorandom real number in the range xmin to xmax. 

RandomReal[xmax] gives a pseudorandom real number in the range 0 to xmax.

RandomReal[range,n] gives a list of n pseudorandom reals. 

RandomReal[range,{n1,n2,…}] gives an n1×n2×… array of pseudorandom reals. 

RandomSample

RandomSample[{e1,e2,…},n] gives a pseudorandom sample of n of the ei.

RandomSample[{w1,w2,…}->{e1,e2,…},n] gives a pseudorandom sample of n of the ei chosen using weights wi.

RandomSample[{e1,e2,…}] gives a pseudorandom permutation of the ei.

RandomSeeding

RandomSeeding is an option that specifies what seeding of pseudorandom generators should be done inside the operation of a function.

RandomTree

RandomTree[n] gives a pseudorandom tree with n nodes.

RandomTree[n,k] gives a list of k pseudorandom trees.

RandomTree[n,{k1,k2,…}] gives a k1× k2×… array of trees.

RandomVariate

RandomVariate[dist] gives a pseudorandom variate from the symbolic distribution dist.

RandomVariate[dist,n] gives a list of n pseudorandom variates from the symbolic distribution dist.

RandomVariate[dist,{n1,n2,…}] gives an n1× n2×… array of pseudorandom variates from the symbolic distribution dist.

RandomWalkProcess

RandomWalkProcess[p] represents a random walk on a line with the probability of a positive unit step p and the probability of a negative unit step 1-p.

RandomWalkProcess[p,q] represents a random walk with the probability of a positive unit step p, the probability of a negative unit step q, and the probability of a zero step 1-p-q.

RandomWord

RandomWord[] gives a pseudorandom commonly used word.

RandomWord[n] gives a list of n pseudorandom words.

RandomWord[type] gives a pseudorandom word of the specified type.

RandomWord[type,n] gives a list of n pseudorandom words of the specified type.

Range

Range[imax] generates the list {1,2,…,imax}. 

Range[imin,imax] generates the list {imin,…,imax}. 

Range[imin,imax,di] uses step di.

RankedMax

RankedMax[list,n] gives the nth largest element in list.

RankedMax[list,-n] gives the nth smallest element in list.

RankedMin

RankedMin[list,n] gives the nth smallest element in list.

RankedMin[list,-n] gives the nth largest element in list.

RarerProbability

RarerProbability[dist,example] computes the probability for distribution dist to generate a sample that has a lower or equal PDF than example.

RarerProbability[dist,{ex1,ex2,…}] computes the rarer probability for each exi. 

Raster

Raster[{{a11,a12,…},…}] is a two-dimensional graphics primitive which represents a rectangular array of gray cells. 

Raster[{{{r11,g11,b11},…},…}] represents an array of RGB color cells. 

Raster[{{{r11,g11,b11,α11},…},…}] represents an array of color cells with opacity αij. 

Raster[{{{a11,α11},…},…}] represents an array of gray cells with the specified opacities. 

Raster3D

Raster3D[{{{a11,a12,…},…},…}] is a three-dimensional graphics primitive that represents a cubical array of gray cells. 

Raster3D[{{{{r11,g11,b11},…},…},…}] represents an array of RGB color cells. 

Raster3D[{{{{r11,g11,b11,α11},…},…},…}] represents an array of color cells with opacity αij.

Raster3D[array,{{xmin,ymin,zmin},{xmax,ymax,zmax}}] represents a three-dimensional graphics primitive by giving the coordinates of opposite corners.

Raster3D[array,coordinates,{amin,amax}] represents a three-dimensional graphics primitive whose voxel values should be scaled so that amin corresponds to 0 and amax corresponds to 1.

RasterArray

RasterArray[{{g11,g12,…},…}] is a two-dimensional graphics primitive that represents a rectangular array of cells colored according to the graphics directives gij. 

Rasterize

Rasterize[expr] returns a rasterized version of the displayed form of expr.

Rasterize[expr,elem] gives the element elem associated with the rasterized form of expr. 

Rasterize[expr,{elem1,elem2,…}] gives a list of the specified elemi.

RasterSize

RasterSize is an option for Rasterize and related functions that determines the absolute pixel size of the raster generated.

Rational

Rational is the head used for rational numbers. 

RationalExpressionQ

RationalExpressionQ[expr,x] gives True if expr is structurally a rational expression in x, and False otherwise.

RationalExpressionQ[expr,{x,y,…}] gives True if expr is structurally a rational expression in x,y,…, and False otherwise.

RationalExpressionQ[expr,{x,y,…},test] gives True if expr is structurally a rational expression in x,y,… with coefficients satisfying test, and False otherwise.

Rationalize

Rationalize[x] converts an approximate number x to a nearby rational with small denominator. 

Rationalize[x,dx] yields the rational number with smallest denominator that lies within dx of x.

Rationals

Rationals represents the domain of rational numbers, as in x∈Rationals. 

Ratios

Ratios[list] gives the successive ratios of elements in list. 

Ratios[list,n] gives the nth iterated ratios of list. 

Ratios[list,{n1,n2,…}] gives the successive nkth ratios at level k in a nested list. 

RawMedium

RawMedium is an internal symbol.

RayleighDistribution

RayleighDistribution[σ] represents the Rayleigh distribution with scale parameter σ.

Re

Re[z] gives the real part of the complex number z. 

ReactionBalance

ReactionBalance[rxn] returns a version of the reaction rxn in which the stoichiometric coefficients for elements in the reactants and products are balanced.

ReactionBalancedQ

ReactionBalancedQ[rxn] returns True if the given chemical reaction is balanced, and False otherwise.

ReactionPDETerm

ReactionPDETerm[vars,a] represents a reaction term a u with reaction coefficient a and with model variables vars.

ReactionPDETerm[{u,{x1,…,xn}},a,pars] uses model parameters pars.

Read

Read[stream] reads one expression from an input stream and returns the expression. 

Read[stream,type] reads one object of the specified type. 

Read[stream,{type1,type2,…}] reads a sequence of objects of the specified types. 

ReadByteArray

ReadByteArray[src] gives the contents of src as a ByteArray object.

ReadByteArray[src,n] reads the first n bytes from src.

ReadByteArray[src,term] reads until the termination condition term is satisfied.

ReadLine

ReadLine[stream] reads a line of text from a stream and returns it as a string.

ReadLine[proc] reads a line of text generated by an external process and returns it as a string.

ReadList

ReadList["file"] reads all the remaining expressions in a file and returns a list of them. 

ReadList["file",type] reads objects of the specified type from a file, until the end of the file is reached. The list of objects read is returned. 

ReadList["file",{type1,type2,…}] reads objects with a sequence of types, until the end of the file is reached. 

ReadList["file",types,n] reads only the first n objects of the specified types. 

ReadProtected

ReadProtected is an attribute that prevents values associated with a symbol from being seen. 

ReadString

ReadString["file"] reads the complete contents of a file and returns it as a string.

ReadString[stream] reads everything from a stream and returns it as a string.

ReadString[proc] reads everything generated by an external process and returns it as a string.

ReadString[src,term] reads until the terminator term is encountered.

Real

Real is the head used for real (floating‐point) numbers. 

RealAbs

RealAbs[x] gives the absolute value of the real number x. 

RealBlockDiagonalForm

RealBlockDiagonalForm is an option for SchurDecomposition and related functions which specifies whether 2×2 blocks of real values should be used on matrix diagonals in place of complex values.

RealExponent

RealExponent[x] gives log10(x).

RealExponent[x,b] gives logb(x).

Reals

Reals represents the domain of real numbers, as in x∈Reals. 

RealSign

RealSign[x] gives -1, 0 or 1 depending on whether x is negative, zero or positive. 

Reap

Reap[expr] gives the value of expr together with all expressions to which Sow has been applied during its evaluation. Expressions sown using Sow[e] or Sow[e,tagi] with different tags are given in different lists. 

Reap[expr,patt] reaps only expressions sown with tags that match patt. 

Reap[expr,{patt1,patt2,…}] puts expressions associated with each of the patti in a separate list. 

Reap[expr,patt,f] returns {expr,{f[tag1,{e11,e12,…}],…}}. 

RebuildPacletData

The experimental function RebuildPacletData is now obsolete and is superseded by PacletDataRebuild.

RecalibrationFunction

RecalibrationFunction is an option for Classify, Predict and related functions that specifies how to post-process model predictions.

RecognitionPrior

RecognitionPrior is an option for recognition functions that specifies the prior probability or class for recognition.

RecognitionThreshold

RecognitionThreshold is an option for ImageInstanceQ and related functions that specifies the minimum estimated probability at which recognition is considered acceptable. 

Record

Record represents a record in Read, Find, and related functions. 

RecordLists

RecordLists is an option for ReadList that specifies whether objects from separate records should be returned in separate sublists. 

RecordSeparators

RecordSeparators is an option for Read, Find, and related functions that specifies the list of strings to be taken as delimiters for records. 

Rectangle

Rectangle[{xmin,ymin},{xmax,ymax}] represents an axis-aligned filled rectangle from {xmin,ymin} to {xmax,ymax}.

Rectangle[{xmin,ymin}] corresponds to a unit square with its bottom-left corner at {xmin,ymin}.

RectangleChart

RectangleChart[{{x1,y1},{x2,y2},…}] makes a rectangle chart with bars of width xi and height yi. 

RectangleChart[{…,wi[{xi,yi},…],…,wj[{xi,yj},…],…}] makes a rectangle chart with bar features defined by the symbolic wrappers wk.

RectangleChart[{data1,data2,…}] makes a rectangle chart from multiple datasets datai. 

RectangleChart3D

RectangleChart3D[{{x1,y1,z1},{x2,y2,z2},…}] makes a 3D rectangle chart with bars of width xi, depth yi, and height zi.

RectangleChart3D[{…,wi[{xi,yi,zi},…],…,wj[{xi,yj,zj},…],…}] makes a 3D rectangle chart with bar features defined by the symbolic wrappers wk.

RectangleChart3D[{data1,data2,…}] makes a 3D rectangle chart from multiple datasets datai. 

RectangularRepeatingElement

RectangularRepeatingElement[elem] represents a rectangular array of elements of type spec in an interpreter, API or form specification.

RectangularRepeatingElement[elem,{maxrows,maxcolumns}] represents a rectangular array of elements of maximum size maxrows×maxcolums.

RectangularRepeatingElement[elem,{{minrows,maxrows},{mincolumns,maxcolumns}}] represents a rectangular array of elements of dimensions between minrows×mincolumns and maxrows×maxcolums.

RecurrenceFilter

RecurrenceFilter[{α,β},x] filters x using a linear recurrence equation with coefficients α and β.

RecurrenceFilter[tf,x] uses a discrete-time filter defined by the TransferFunctionModel tf.

RecurrenceFilter[…,x,{y0,y-1,…}] uses a specified list {y0,y-1,…} as the initial condition.

RecurrenceFilter[…,image] filters image.

RecurrenceFilter[…,sound] filters sampled sound object.

RecurrenceTable

RecurrenceTable[eqns,expr,{n,nmax}] generates a list of values of expr for successive n based on solving the recurrence equations eqns.

RecurrenceTable[eqns,expr,nspec] generates a list of values of expr over the range of n values specified by nspec.

RecurrenceTable[eqns,expr,{n1,…},{n2,…},…] generates an array of values of expr for successive n1, n2, … .

Red

Red represents the color red in graphics or style specifications. 

Reduce

Reduce[expr,vars] reduces the statement expr by solving equations or inequalities for vars and eliminating quantifiers. 

Reduce[expr,vars,dom] does the reduction over the domain dom. Common choices of dom are Reals, Integers, and Complexes. 

ReferenceLineStyle

ReferenceLineStyle is an option for QuantilePlot and similar functions that specifies the style used for the reference line. 

Refine

Refine[expr,assum] gives the form of expr that would be obtained if symbols in it were replaced by explicit numerical expressions satisfying the assumptions assum. 

Refine[expr] uses default assumptions specified by any enclosing Assuming constructs. 

ReflectionMatrix

ReflectionMatrix[v] gives the matrix that represents reflection of points in a mirror normal to the vector v.

ReflectionTransform

ReflectionTransform[v] gives a TransformationFunction that represents a reflection in a mirror through the origin, normal to the vector v.

ReflectionTransform[v,p] gives a reflection in a mirror through the point p, normal to the vector v.

Refresh

Refresh[expr,interval,opts] represents an object whose value should be refreshed at times specified by the options opts.

RefreshRate

RefreshRate is an option to Animate and related functions which specifies the refresh rate for frames in animations.

Region

Region[reg] represents a geometric region.

Region[reg,options] gives a region that uses the specified options.

RegionBinarize

RegionBinarize[image,marker,d] gives a binary version of image that includes the foreground pixels of marker and also connected regions whose pixel values are within a distance d.

RegionBinarize[image,marker,d,{t1,t2}] grows regions in marker by adding pixels whose average intensity is also constrained within an interval {t1,t2}.

RegionBoundary

RegionBoundary[reg] represents the boundary of the region reg.

RegionBoundaryStyle

RegionBoundaryStyle is an option for plotting functions that specifies the boundary style for the region over which the plot is being drawn.

RegionBounds

RegionBounds[reg] gives the bounds for the region reg.

RegionBounds[reg,"type"] gives region bounds of the specified "type". 

RegionCentroid

RegionCentroid[reg] gives the centroid of the region reg.

RegionCongruent

RegionCongruent[reg1,reg2] tests whether the regions reg1 and reg2 are congruent.

RegionConvert

RegionConvert[reg,form] converts the region representation reg to the specified form.

RegionDifference

RegionDifference[reg1,reg2] gives the difference of the regions reg1 and reg2.

RegionDilation

RegionDilation[reg,r] gives the dilation of the region reg by a disk of radius r centered at the origin.

RegionDilation[reg1,reg2] gives the dilation of the region reg1 by the region reg2.

RegionDilation[reg1,reg2,{u,v}] gives the dilation of reg1 scaled by a factor u and reg2 scaled by a factor v.

RegionDimension

RegionDimension[reg] gives the geometric dimension of the region reg. 

RegionDisjoint

RegionDisjoint[reg1,reg2] returns True if the regions reg1 and reg2 are disjoint. 

RegionDisjoint[reg1,reg2,reg3,…] returns True if the regions reg1, reg2, reg3, … are pairwise disjoint.

RegionDistance

RegionDistance[reg,p] gives the minimum distance from the point p to the region reg.

RegionDistance[reg1,reg2] gives the minimum distance between points in the regions reg1 and reg2.

RegionDistance[reg] gives a RegionDistanceFunction[…] that can be applied repeatedly to different points.

RegionDistanceFunction

RegionDistanceFunction[reg,…]  represents a function whose values give the distance from a point to the region reg.

RegionEmbeddingDimension

RegionEmbeddingDimension[reg] gives the dimension of the space in which the region reg is embedded. 

RegionEqual

RegionEqual[reg1,reg2] returns True if the regions reg1 and reg2 are equal.

RegionEqual[reg1,reg2,reg3,…] returns True if the regions reg1, reg2, reg3, … are all equal.

RegionErosion

RegionErosion[reg,r] gives the erosion of the region reg by a disk of radius r centered at the origin.

RegionErosion[reg1,reg2] gives the erosion of the region reg1 by the region reg2.

RegionErosion[reg1,reg2,{u,v}] gives the erosion of reg1 scaled by a factor u and reg2 scaled by a factor v.

RegionFillingStyle

RegionFillingStyle is an option for plotting functions that specifies the style for the filled region over which the plot is being drawn.

RegionFit

RegionFit[{p1,p2,…},"model"] finds a geometric region "model" that best fits the points p1,p2,….

RegionFit[{p1,p2,…},"model","prop"] specifies what fit property "prop" should be returned.

RegionFunction

RegionFunction is an option for plotting functions that specifies the region to include in the plot drawn. 

RegionImage

RegionImage[reg] returns a rasterized grayscale 2D or 3D image of reg.

RegionImage[reg,{{xmin,xmax},…}] restricts to the bounds [xmin,xmax]×⋯.

RegionIntersection

RegionIntersection[reg1,reg2,…] gives the intersection of the regions reg1, reg2, ….

RegionMeasure

RegionMeasure[reg] gives the measure of the region reg.

RegionMeasure[reg,d] gives the d-dimensional measure of the region reg.

RegionMeasure[{x1,…,xn},{{t1,a1,b1},…,{tk,ak,bk}}] gives the k-measure of the parametric formula whose Cartesian coordinates xi are functions of tj.

RegionMeasure[{x1,…,xn},{{t1,a1,b1},…,{tk,ak,bk}},chart] interprets the xi as coordinates in the specified coordinate chart.

RegionMember

RegionMember[reg,{x,y,…}] gives True if the numeric point {x,y,…} is a member of the constant region reg and False otherwise.

RegionMember[reg,{x,y,…}] gives conditions for the point {x,y,…} to be a member of reg.

RegionMember[reg] returns a RegionMemberFunction[…] that can be applied repeatedly to different points. 

RegionMemberFunction

RegionMemberFunction[reg,…]  represents a function whose values give whether a point is in a region reg or not.

RegionMoment

RegionMoment[reg,{i1,i2,…,in}] computes the polynomial moment ∫x∈regx1i1 x2i2 ⋯ xnin for the region reg.

RegionNearest

RegionNearest[reg,p] gives a point in the region reg that is nearest the point p. 

RegionNearest[reg] gives a RegionNearestFunction[…] that can be repeatedly applied to points. 

RegionNearestFunction

RegionNearestFunction[reg,…]  represents a function whose values give the nearest point in the region reg.

RegionPlot

RegionPlot[pred,{x,xmin,xmax},{y,ymin,ymax}] makes a plot showing the region in which pred is True. 

RegionPlot[{pred1,pred2,…},…] plots several regions corresponding to the predi.

RegionPlot[{…,w[predi,…],…},…] plots predi with features defined by the symbolic wrapper w.

RegionPlot3D

RegionPlot3D[pred,{x,xmin,xmax},{y,ymin,ymax},{z,zmin,zmax}] makes a plot showing the three-dimensional region in which pred is True. 

RegionPlot3D[{pred1,pred2,…},…] plots several regions corresponding to the predi.

RegionProduct

RegionProduct[reg1,reg2] represents the Cartesian product of the regions reg1 and reg2.

RegionProduct[reg1,reg2,…] represents the Cartesian product of the regions reg1, reg2, ….

RegionQ

RegionQ[reg] gives True if reg is a valid region and False otherwise. 

RegionResize

RegionResize[reg,l] resize the region reg to have the first side length l preserving side length ratios. 

RegionResize[reg,{lmax}] resize into a box with maximum side length lmax preserving side length ratios.

RegionResize[reg,{l1,l2,…}] resize into a box with side lengths li. 

RegionResize[reg,{{x1,min,x1,max},{x2,min,x2,max},…}] resize into a box with corners {x1,min,x2,min,…} and {x1,max,x2,max,…}.

RegionSimilar

RegionSimilar[reg1,reg2] tests whether the regions reg1 and reg2 are similar.

RegionSize

RegionSize is an option used by Printout3D to specify the overall size of an object to print for a region.

RegionSymmetricDifference

RegionSymmetricDifference[reg1,reg2,…] represents the symmetric difference of the regions reg1, reg2, ….

RegionUnion

RegionUnion[reg1,reg2,…] gives the union of the regions reg1, reg2, ….

RegionWithin

RegionWithin[reg1,reg2] returns True if reg2 is contained within reg1.

RegisterExternalEvaluator

RegisterExternalEvaluator[sys,evaluator] registers the evaluator for use as an external evaluator with the language or system sys.

RegisterExternalEvaluator[sys,evaluator,name] registers the evaluator using the assigned name name.

RegularExpression

RegularExpression["regex"] represents the generalized regular expression specified by the string "regex". 

Regularization

Regularization is an option for Sum and Product that specifies what type of regularization to use.

RegularlySampledQ

RegularlySampledQ[tseries] gives True if tseries is a regular time series, and False otherwise.

RegularPolygon

RegularPolygon[n] gives the regular polygon with n vertices equally spaced around the unit circle.

RegularPolygon[r,n] gives the regular polygon of radius r.

RegularPolygon[{r,θ},n] starts at angle θ with respect to the x axis.

RegularPolygon[{x,y},rspec,n] centers the polygon at {x,y}.

ReIm

ReIm[z] gives the list {Re[z],Im[z]} of the number z.

ReImLabels

ReImLabels is an option for ReImPlot that specifies labels to use for the real and imaginary components.

ReImPlot

ReImPlot[f,{x,xmin,xmax}] generates a plot of Re[f] and Im[f] as functions of x∈ from xmin to xmax.

ReImPlot[{f1,f2,…},{x,xmin,xmax}] plots several functions.

ReImPlot[{…,w[fi],…},…] plots fi with features defined by the symbolic wrapper w.

ReImPlot[…,{x}∈reg] takes the variable x to be in the geometric region reg.

ReImStyle

ReImStyle is an option for ReImPlot that specifies styles to use for the real and imaginary components.

Reinstall

Reinstall[link] un-installs the specified external package and installs it again.

RelationalDatabase

RelationalDatabase[…] represents schema information about a relational database.

RelationalDatabase[db] gives the complete schema of the database referenced by db.

RelationalDatabase[{table1 table2,…},db] gives schema information related to the tables tablei.

RelationGraph

RelationGraph[f,{v1,v2,…}] gives the graph with vertices vi and edges from vi to vj whenever f[vi,vj] is True.

RelationGraph[f,{v1,v2,…},{w1,w2,…}] gives the graph with vertices vi,wj and edges from vi to wj whenever f[vi,wj] is True.

ReleaseHold

ReleaseHold[expr] removes Hold, HoldForm, HoldPattern, HoldComplete and HoldCompleteForm in expr. 

ReliabilityDistribution

ReliabilityDistribution[bexpr,{{x1,dist1},{x2,dist2},…}] represents the reliability distribution for a system with components xi having reliability distribution disti, where the whole system is working when the Boolean expression bexpr is True, and component xi is working when xi is True.

ReliefImage

ReliefImage[array] generates a relief image of an array of height values. 

ReliefPlot

ReliefPlot[array] generates a relief plot of an array of height values. 

RemoteAuthorizationCaching

RemoteAuthorizationCaching is an option for RemoteConnect and related functions that determines whether caching of authorization information on remote hosts should be used.

RemoteBatchJobAbort

RemoteBatchJobAbort[job] aborts a remote batch job.

RemoteBatchJobObject

RemoteBatchJobObject[…] represents a remote batch job submitted by RemoteBatchSubmit or RemoteBatchMapSubmit.

RemoteBatchJobs

RemoteBatchJobs[env] gives a list of RemoteBatchJobObject expressions representing batch jobs submitted using env.

RemoteBatchJobs[env,type] returns only jobs of given type.

RemoteBatchJobs[] gives a list of jobs submitted using $DefaultRemoteBatchSubmissionEnvironment.

RemoteBatchMapSubmit

RemoteBatchMapSubmit[env,f,list] submits an array batch job in which f is applied to each element on the first level of list, using the remote batch submission environment env.

RemoteBatchMapSubmit[f,list] submits an array job using $DefaultRemoteBatchSubmissionEnvironment.

RemoteBatchSubmissionEnvironment

RemoteBatchSubmissionEnvironment["provider",assoc] represents a remote batch job submission environment for provider with properties assoc.

RemoteBatchSubmissionEnvironment["provider"] represents a submission environment for provider with default optional properties.

RemoteBatchSubmit

RemoteBatchSubmit[env,expr] submits expr for evaluation using the remote batch submission environment env.

RemoteBatchSubmit[expr] submits expr for evaluation using $DefaultRemoteBatchSubmissionEnvironment.

RemoteConnect

RemoteConnect["host"] connects to the specified remote host.

RemoteConnect[IPAddress["address"]] connects to the machine with the specified IP address.

RemoteConnect["host",username] connects using the specified username for the remote host.

RemoteConnect["host",username,password] connects using the specified username and password.

RemoteConnectionObject

RemoteConnectionObject[…] is an object that represents a remote connection.

RemoteEvaluate

RemoteEvaluate[expr] gives the result of evaluating expr using your current default remote Wolfram Language kernel.

RemoteEvaluate[ker, expr] gives the result of evaluating expr using the kernel specified by ker.

RemoteEvaluate[{ker1,ker2,…},expr] gives a list of the results of evaluating expr using each of the kernels keri.

RemoteEvaluate[ker,expr,h] wraps the head h around the result produced before returning it.

RemoteFile

RemoteFile[URL["uri"]] is a symbolic representation of a file on a remote machine.

RemoteInputFiles

RemoteInputFiles is an option for RemoteBatchSubmit and RemoteBatchMapSubmit that specifies local files to be uploaded and made available within remote jobs.

RemoteKernelObject

RemoteKernelObject[spec] specifies a remote kernel that can be used for RemoteEvaluate or LaunchKernels.

RemoteProviderSettings

RemoteProviderSettings is an option for RemoteBatchSubmit and RemoteBatchMapSubmit that specifies provider-specific settings for a batch job.

RemoteRun

RemoteRun["host","command"] runs the specified operating system command on the remote host, returning the exit code obtained.

RemoteRun[IPAddress["address"],"command"] runs the command on the machine with the specified IP address.

RemoteRun[obj,"command"] run the command on the remote host specified by the RemoteConnectionObject obj.

RemoteRunProcess

RemoteRunProcess["host","command"] runs the specified system command on the remote host, returning information on the outcome.

RemoteRunProcess[IPAddress["address"],"command"] runs the command on the machine with the specified IP address.

RemoteRunProcess[obj,"command"] run the command on the remote host specified by the RemoteConnectionObject obj.

RemoteRunProcess["host",{"command",arg1,arg2,…}] runs the specified command, with command-line arguments argi.

RemoteRunProcess["host", command,"prop"] returns only the specified property.

RemoteRunProcess["host", command,prop,input] feeds the specified initial input to the command.

RemovalConditions

RemovalConditions is an option for AttachCell that specifies conditions under which to remove the attached cell.

Remove

Remove[s1,s2,…] removes the symbols si completely, so that their names are no longer recognized by the Wolfram Language.

Remove[patt1,patt2,…] removes all symbols whose names textually match any of the arbitrary string patterns patti.

Remove[{spec1,spec2,…}] removes any symbols that are equal to or whose names match any of the speci.

RemoveAlphaChannel

RemoveAlphaChannel[color] removes opacity from color.

RemoveAlphaChannel[color,bg] removes opacity by blending color with the background color bg.

RemoveAlphaChannel[image,…] removes opacity from all pixels in image.

RemoveAlphaChannel[video,…] removes opacity from frames of video.

RemoveAsynchronousTask

RemoveAsynchronousTask[asyncTask] stops asynchronous evaluations and removes asyncTask from the system.

RemoveAudioStream

RemoveAudioStream[] deletes all AudioStream objects.

RemoveAudioStream[stream] deletes the AudioStream object stream.

RemoveAudioStream[audio] deletes all the AudioStream objects stemming from audio.

RemoveBackground

RemoveBackground[image] returns an image with an alpha channel where the background is transparent. 

RemoveBackground[image,model] uses foreground or background model specification.

RemoveBackground[video,…] performs background removal on frames of video.

RemoveChannelListener

RemoveChannelListener[obj] removes obj from the list of currently active channel listeners.

RemoveChannelListener[{obj1,obj2,…}] removes all the obji.

RemoveChannelListener[] removes all currently active channel listeners.

RemoveChannelSubscribers

RemoveChannelSubscribers[channel] removes all subscribers from the specified channel.

RemoveChannelSubscribers[channel,user] removes the specified user from the subscriber list.

RemoveChannelSubscribers[channel,{user1,user2,…}] removes the specified subscribers useri.

Removed

Removed[string] is printed to indicate a symbol that has been removed.

RemoveDiacritics

RemoveDiacritics[string] replaces characters in string that have diacritics by their base ASCII characters, when possible.

RemoveInputStreamMethod

RemoveInputStreamMethod["name"] removes a custom input stream method.

RemoveOutputStreamMethod

RemoveOutputStreamMethod["name"] removes a custom output stream method.

RemoveProperty

RemoveProperty[{obj,itemspec}] removes all properties associated with itemspec in obj.

RemoveProperty[{obj,itemspec},name] removes the property name associated with itemspec in obj.

RemoveUsers

RemoveUsers[group,{user1,…}] removes the users useri from the permissions group group.

RemoveVideoStream

RemoveVideoStream[] deletes all VideoStream objects.

RemoveVideoStream[stream] deletes the VideoStream object stream.

RenameDirectory

RenameDirectory[dir1,dir2] renames the directory dir1 to dir2. 

RenameFile

RenameFile[file1,file2] renames file1 to file2. 

RenderAll

RenderAll is an option for Graphics3D that specifies whether or not PostScript should be generated for all polygons. 

RenderingOptions

RenderingOptions is an option for Style, Cell and related constructs that specifies options related to 3D rendering.

RenewalProcess

RenewalProcess[rdist] represents a renewal process with interarrival times distributed according to rdist.

RenkoChart

RenkoChart[{{date1,p1},{date2,p2},…}] makes a Renko chart with prices pi at date datei.

RenkoChart[{"name",daterange}] makes a Renko chart of closing prices for the financial entity "name" over the date range daterange.

RenkoChart[{…},s] makes a Renko chart with brick height of fraction s of the average price.

RepairMesh

RepairMesh[mreg] repairs defects in the mesh region mreg.

RepairMesh[mreg,{def1,…}] repairs only the specified defects def1,….

Repeated

p.. or Repeated[p] is a pattern object that represents a sequence of one or more expressions, each matching p. 

Repeated[p,max] represents from 1 to max expressions matching p.

Repeated[p,{min,max}] represents between min and max expressions matching p.

Repeated[p,{n}] represents exactly n expressions matching p.

RepeatedNull

p... or RepeatedNull[p] is a pattern object that represents a sequence of zero or more expressions, each matching p. 

RepeatedNull[p,max] represents from 0 to max expressions matching p.

RepeatedNull[p,{min,max}] represents between min and max expressions matching p.

RepeatedNull[p,{n}] represents exactly n expressions matching p.

RepeatedTiming

RepeatedTiming[expr] evaluates expr repeatedly and returns a list of the average time in seconds used, together with the result obtained.

RepeatedTiming[expr,t] does repeated evaluation for at least t seconds. 

RepeatingElement

RepeatingElement[spec] represents an arbitrarily repeated type of element in an interpreter, API or form specification.

RepeatingElement[spec,max] represents an element that can appear at most max times.

RepeatingElement[spec,{min,max}] represents an element that can appear between min and max times.

RepeatingElement[spec,{n,{min,max}}] represents an element that initially appears n times in a form.

RepeatingElement[spec,{{i,n},{min,max}}] represents an element where i takes successive values.

Replace

Replace[expr,rules] applies a rule or list of rules in an attempt to transform the entire expression expr. 

Replace[expr,rules,levelspec] applies rules to parts of expr specified by levelspec. 

Replace[rules] represents an operator form of Replace that can be applied to an expression.

ReplaceAll

expr/.rules or ReplaceAll[expr,rules] applies a rule or list of rules in an attempt to transform each subpart of an expression expr. 

ReplaceAll[rules] represents an operator form of ReplaceAll that can be applied to an expression.

ReplaceImageValue

ReplaceImageValue[image,pos->val] changes the pixel values at position pos in image to val.

ReplaceImageValue[image,pos->val,"type"] assumes val to be of the specified type.

ReplaceList

ReplaceList[expr,rules] attempts to transform the entire expression expr by applying a rule or list of rules in all possible ways, and returns a list of the results obtained. 

ReplaceList[expr,rules,n] gives a list of at most n results. 

ReplaceList[rules] is an operator form of ReplaceList that can be applied to an expression.

ReplacePart

ReplacePart[expr,i->new] yields an expression in which the ith part of expr is replaced by new. 

ReplacePart[expr,{i1->new1,i2->new2,…}] replaces parts at positions in by newn. 

ReplacePart[expr,{i,j,…}->new] replaces the part at position {i,j,…}. 

ReplacePart[expr,{{i1,j1,…}->new1,…}] replaces parts at positions {in,jn,…} by newn. 

ReplacePart[expr,{{i1,j1,…},…}->new] replaces all parts at positions {in,jn,…} by new. 

ReplacePart[i->new] represents an operator form of ReplacePart that can be applied to an expression.

ReplacePixelValue

ReplacePixelValue[image,ppos->val] changes the pixel values at pixel position ppos in image to val.

ReplacePixelValue[image,ppos->val,"type"] assumes val to be of the specified type.

ReplaceRepeated

expr//.rules repeatedly performs replacements until expr no longer changes. 

ReplaceRepeated[rules] represents an operator form of ReplaceRepeated that can be applied to an expression.

ReplicateLayer

ReplicateLayer[n] represents a net layer that takes an input of dimensions {d1,d2,…} and replicates it n times to produce an output of dimensions {n,d1,d2,…}.

ReplicateLayer[{n1,n2,…,nm}] represents a net layer that takes an input of dimensions {d1,d2,…} and replicates it to produce an output of dimensions {n1,n2,…,nm,d1,d2,…}.

ReplicateLayer[dims,m] replicates so that dims appears at position m in the list of output dimensions. 

RequiredPhysicalQuantities

RequiredPhysicalQuantities is an option for FormulaLookup that specifies physical quantities that must be used by the formulas returned.

Resampling

Resampling is an option that specifies the method to be used for resampling images or arrays.

ResamplingAlgorithmData

ResamplingAlgorithmData[rs,"prop"] gives the specified property "prop" for the resampling rs.

ResamplingMethod

ResamplingMethod is an option for functions such as TemporalData and MovingMap that specifies how values in between given times should be computed.

Rescale

Rescale[x,{min,max}] gives x rescaled to run from 0 to 1 over the range min to max. 

Rescale[x,{min,max},{ymin,ymax}] gives x rescaled to run from ymin to ymax over the range min to max. 

Rescale[list] rescales each element of list to run from 0 to 1 over the range Min[list] to Max[list]. 

RescalingTransform

RescalingTransform[{{xmin,xmax},{ymin,ymax},…},{{xpmin,xpmax},…}] gives a TransformationFunction that rescales the region with coordinate ranges xmin to xmax, etc. to the region with coordinate ranges xpmin to xpmax, etc.

RescalingTransform[{{xmin,xmax},{ymin,ymax},…}] gives a TransformationFunction that rescales to the unit square, cube, etc.

ResetDirectory

ResetDirectory[] resets the current working directory to its previous value. 

ResetScheduledTask

ResetScheduledTask[obj,timespec]  resets the timing for a scheduled task to timespec.

ResetScheduledTask[obj,timespec,offset] resets the time offset for a scheduled task to offset.

ReshapeLayer

ReshapeLayer[spec] represents a net layer that reshapes the input array according to the specification spec.

Residue

Residue[expr,{z,z0}] finds the residue of expr at the point z=z0. 

ResizeLayer

ResizeLayer[{d}] represents a layer performing one-dimensional resizing of a two-dimensional array.

ResizeLayer[{d1,…,dn}] represents a layer performing n-dimensional resizing of a (n+1)-dimensional array.

Resolve

Resolve[expr] attempts to resolve expr into a form that eliminates ForAll and Exists quantifiers. 

Resolve[expr,dom] works over the domain dom. Common choices of dom are Complexes, Reals, and Booleans. 

ResolveContextAliases

ResolveContextAliases is an option for Names, Contexts and related functions to control whether to resolve aliases when searching for symbols that match a string pattern.

ResourceData

ResourceData[resource] gives the primary content of the specified resource.

ResourceData[resource,elem] gives element elem of the content of the resource. 

ResourceFunction

ResourceFunction[resource] represents the function associated with the specified resource.

ResourceFunction[resource,prop] gives the specified property of the resource.

ResourceObject

ResourceObject["name"] represents a resource with the specified name.

ResourceObject["uuid"] represents a resource with the specified UUID.

ResourceObject[loc] imports a resource from the specified location.

ResourceObject[assoc] gives a resource with content and metadata specified by the association assoc.

ResourceRegister

ResourceRegister[resource] creates a persistent cache of a resource object that can be referenced by name.

ResourceRegister[resource, loc] stores the resource in persistence location loc.

ResourceRegister[resource, {loc1,…}] stores the resource in multiple persistence locations.

ResourceRemove

ResourceRemove[resource] removes the specified resource from the system on which it is run.

ResourceSearch

ResourceSearch[form] gives a dataset of resources that contain text matching form.

ResourceSearch[form,prop] returns the property prop of the search results.

ResourceSubmit

ResourceSubmit[resource] submits the specified resource object to be reviewed for publication.

ResourceSubmit[new,old] submits the resource new as the updated version of the resource old.

ResourceUpdate

ResourceUpdate[resource] updates to the latest version of the specified resource object.

ResourceUpdate["name"] updates the resource with the specified name.

ResourceVersion

ResourceVersion is an option for ResourceObject, ResourceFunction and related functions for specifying the version of a resource.

ResponseForm

ResponseForm[expr,"fmt"] represents a response record to be given in a specified format when requested during the execution of a function specified by APIFunction, FormFunction, etc.

ResponseForm[expr,"fmt",{elem1,elem2,…}] includes only the response record elements elemi.

Rest

Rest[expr] gives expr with the first element removed. 

RestartInterval

RestartInterval is an option controlling the restart behavior of functions such as ContinuousTask.

Restricted

Restricted[form,cond,…] represents a form for Interpreter and related functions restricted according to the conditions cond.

Resultant

Resultant[poly1,poly2,var] computes the resultant of the polynomials poly1 and poly2 with respect to the variable var. 

Resultant[poly1,poly2,var,Modulus->p] computes the resultant modulo the prime p. 

ResumePacket

ResumePacket[] is a WSTP packet used for synchronization with the Wolfram Language kernel.

Return

Return[expr] returns the value expr from a function. 

Return[] returns the value Null. 

ReturnExpressionPacket

ReturnExpressionPacket[expr] is a WSTP packet that contains the expression expr, the result of an EnterExpressionPacket evaluation.

ReturnPacket

ReturnPacket[expr] is a WSTP packet that contains the expression expr, the result of an EvaluatePacket evaluation.

ReturnReceiptFunction

ReturnReceiptFunction is an option for MailReceiverFunction that specifies what function to apply if a return receipt is requested for mail received by a MailReceiverFunction.

ReturnTextPacket

ReturnTextPacket[string] is a WSTP packet containing string, the result of an EnterTextPacket evaluation.

Reverse

Reverse[expr] reverses the order of the elements in expr. 

Reverse[expr,n] reverses elements at level n in expr.

Reverse[expr,{n1,n2,…}] reverses elements at levels n1, n2, … in expr.

ReverseApplied

ReverseApplied[f] represents a form of f that takes arguments in reverse order so that ReverseApplied[f][x1,…,xn] is equivalent to f[xn,…,x1].

ReverseApplied[f,n] represents a form of f that reverses the first n arguments before evaluation.

ReverseElement

ReverseElement[x,y,…] displays as x∋y∋….

ReverseEquilibrium

ReverseEquilibrium[x,y,…] displays as x⇋y⇋….

ReverseGraph

ReverseGraph[g] gives the reverse graph of the directed graph g.

ReverseGraph[{v->w,…}] uses rules v->w to specify the graph g.

ReverseSort

ReverseSort[list] sorts the elements of list into reverse canonical order. 

ReverseSort[list,p] sorts using the ordering function p. 

ReverseSortBy

ReverseSortBy[list,f] sorts the elements of list using the reverse canonical order defined by applying f to each of them.

ReverseSortBy[list,f,p] sorts the elements of list using the function p to compare pairs of results of applying f to each element.

ReverseSortBy[f] represents an operator form of ReverseSortBy that can be applied to an expression.

ReverseUpEquilibrium

ReverseUpEquilibrium[x,y,…] displays as x⥯y⥯….

RevolutionAxis

RevolutionAxis is an option for RevolutionPlot3D which specifies the revolution axis around which the curve should be rotated. 

RevolutionPlot3D

RevolutionPlot3D[fz,{t,tmin,tmax}] generates a plot of the surface of revolution with height fz at radius t.

RevolutionPlot3D[fz,{t,tmin,tmax},{θ,θmin,θmax}] takes the azimuthal angle θ to vary between θmin and θmax.

RevolutionPlot3D[{fx,fz},{t,tmin,tmax}] generates a plot of the surface obtained by rotating the parametric curve with x, z coordinates {fx,fz} around the z axis.

RevolutionPlot3D[{fx,fz},{t,tmin,tmax},{θ,θmin,θmax}] takes the azimuthal angle θ to vary from θmin to θmax.

RevolutionPlot3D[{fx,fy,fz},{t,tmin,tmax},…] plots the surface obtained by rotating the parametric curve with x, y, z coordinates {fx,fy,fz}.

RGBColor

RGBColor[r,g,b] represents a color in the RGB color space, using red, blue and green components. 

RGBColor[r,g,b,a] specifies opacity a. 

RGBColor["string"] returns a color from a hex color or an HTML color name.

RGBColor[color] returns the RGB representation of color.

RiceDistribution

RiceDistribution[α,β] represents a Rice distribution with shape parameters α and β.

RiceDistribution[m,α,β] represents a Norton–Rice distribution with parameters m, α, and β.

RidgeFilter

RidgeFilter[data] computes a measure for the presence of a ridge at every position of data.

RidgeFilter[data,σ] uses the specified ridge scale σ.

RiemannR

RiemannR[x] gives the Riemann prime counting function R(x).

RiemannSiegelTheta

RiemannSiegelTheta[t] gives the Riemann–Siegel function ϑ(t). 

RiemannSiegelZ

RiemannSiegelZ[t] gives the Riemann–Siegel function Z(t). 

RiemannXi

RiemannXi[s] gives the Riemann xi function ξ(s).

Right

Right is a symbol that represents the right-hand side for purposes of alignment and positioning. 

RightArrow

RightArrow[x,y,…] displays as x→y→….

RightArrowBar

RightArrowBar[x,y,…] displays as x⇥y⇥….

RightArrowLeftArrow

RightArrowLeftArrow[x,y,…] displays as x⇄y⇄….

RightComposition

RightComposition[f1,f2,f3,…] represents a composition on the right of the functions f1, f2, f3, ….

RightCosetRepresentative

RightCosetRepresentative[group,g] returns the smallest element in the right coset of products of the elements of group by g.

RightDownTeeVector

RightDownTeeVector[x,y,…] displays as x⥝y⥝….

RightDownVector

RightDownVector[x,y,…] displays as x⇂y⇂….

RightDownVectorBar

RightDownVectorBar[x,y,…] displays as x⥕y⥕….

RightTee

RightTee[x,y] displays as x⊢y.

RightTeeArrow

RightTeeArrow[x,y,…] displays as x↦y↦….

RightTeeVector

RightTeeVector[x,y,…] displays as x⥛y⥛….

RightTriangle

RightTriangle[x,y,…] displays as x⊳y⊳….

RightTriangleBar

RightTriangleBar[x,y,…] displays as x⧐y⧐….

RightTriangleEqual

RightTriangleEqual[x,y,…] displays as x⊵y⊵….

RightUpDownVector

RightUpDownVector[x,y,…] displays as x⥏y⥏….

RightUpTeeVector

RightUpTeeVector[x,y,…] displays as x⥜y⥜….

RightUpVector

RightUpVector[x,y,…] displays as x↾y↾….

RightUpVectorBar

RightUpVectorBar[x,y,…] displays as x⥔y⥔….

RightVector

RightVector[x,y,…] displays as x⇀y⇀….

RightVectorBar

RightVectorBar[x,y,…] displays as x⥓y⥓….

RipleyK

RipleyK[pdata,r] estimates Ripley's K function K(r) at radius r for point data pdata.

RipleyK[pproc,r] computes K(r) for the point process pproc.

RipleyK[bdata,r] computes K(r) for binned data bdata. 

RipleyK[pspec] generates the function K that can be applied repeatedly at different radii r.

RipleyRassonRegion

RipleyRassonRegion[pdata] gives an estimated observation based on the point data pdata. 

RiskAchievementImportance

RiskAchievementImportance[rdist,t] gives the risk achievement importances for all components in the ReliabilityDistribution rdist at time t.

RiskAchievementImportance[fdist,t] gives the risk achievement importances for all components in the FailureDistribution fdist at time t.

RiskReductionImportance

RiskReductionImportance[rdist,t] gives the risk reduction importances for all components in the ReliabilityDistribution rdist at time t.

RiskReductionImportance[fdist,t] gives the risk reduction importances for all components in the FailureDistribution fdist at time t.

RobustConvexOptimization

RobustConvexOptimization[f,ForAll[pars,pcons,vcons],vars] finds values of vars that give the minimum value of f for vars that satisfy the constraints vcons for all possible values of the parameters pars that satisfy the parametric constraints pcons.

RobustConvexOptimization[…,"prop"] specifies what solution property "prop" should be returned.

RogersTanimotoDissimilarity

RogersTanimotoDissimilarity[u,v] gives the Rogers–Tanimoto dissimilarity between Boolean vectors u and v.

RollPitchYawAngles

RollPitchYawAngles[r] gives the roll-pitch-yaw angles {α,β,γ} corresponding to the rotation matrix r.

RollPitchYawAngles[r,{a,b,c}] gives the roll-pitch-yaw angles {α,β,γ} corresponding to rotation order {a,b,c}.

RollPitchYawMatrix

RollPitchYawMatrix[{α,β,γ}] gives the 3D rotation matrix formed by rotating by α around the initial z axis, then by β around the initial y axis, and then by γ around the initial x axis. 

RollPitchYawMatrix[{α,β,γ},{a,b,c}] gives the 3D rotation matrix formed by rotating by α around the fixed a axis, then by β around the fixed b axis, and then by γ around the fixed c axis. 

RomanNumeral

RomanNumeral[n] gives a string corresponding to the Roman numeral form of the integer n.

RootApproximant

RootApproximant[x] converts the number x to one of the "simplest" algebraic numbers that approximates it well.

RootApproximant[x,n] finds an algebraic number of degree at most n that approximates x.

RootIntervals

RootIntervals[{poly1,poly2,…}] gives a list of isolating intervals for the real roots of any of the polyi, together with a list of which polynomials actually have each successive root.

RootIntervals[poly] gives isolating intervals for real roots of a single polynomial. 

RootIntervals[polys,Complexes] gives bounding rectangles for complex roots.

RootLocusPlot

RootLocusPlot[lsys,{k,kmin,kmax}] generates a root locus plot of a linear time-invariant system lsys as the parameter k ranges from kmin to kmax.

RootMeanSquare

RootMeanSquare[list] gives the root mean square of values in list.

RootMeanSquare[dist] gives the root mean square of the distribution dist.

RootOfUnityQ

RootOfUnityQ[a] yields True if a is a root of unity, and yields False otherwise.

RootReduce

RootReduce[expr] attempts to reduce expr to a single Root object. 

Roots

Roots[lhs==rhs,var] yields a disjunction of equations which represent the roots of a polynomial equation. 

RootSum

RootSum[f,form] represents the sum of form[x] for all x that satisfy the polynomial equation f[x]==0. 

Rotate

Rotate[g,θ] represents 2D graphics primitives or any other objects g rotated counterclockwise by θ radians about the center of their bounding box. 

Rotate[g,θ,{x,y}] rotates about the point {x,y}. 

Rotate[g,{u,v}] rotates around the origin, transforming the 2D or 3D vector u to v.

Rotate[g,θ,w] rotates 3D graphics primitives by θ radians around the 3D vector w anchored at the origin.

Rotate[g,θ,w,p] rotates around the 3D vector w anchored at p.

Rotate[g,θ,{u,v}] rotates by angle θ in the plane spanned by 3D vectors u and v.

RotateLabel

RotateLabel is an option for graphics and related functions that specifies whether labels on vertical frame axes should be rotated to be vertical. 

RotateLeft

RotateLeft[expr,n] cycles the elements in expr n positions to the left. 

RotateLeft[expr] cycles one position to the left. 

RotateLeft[expr,{n1,n2,…}] cycles elements at successive levels ni positions to the left. 

RotateRight

RotateRight[expr,n] cycles the elements in expr n positions to the right. 

RotateRight[expr] cycles one position to the right. 

RotateRight[expr,{n1,n2,…}] cycles elements at successive levels ni positions to the right. 

RotationAction

RotationAction is an option for three-dimensional graphics functions that specifies how to render 3D objects when they are interactively rotated.

RotationMatrix

RotationMatrix[θ] gives the 2D rotation matrix that rotates 2D vectors counterclockwise by θ radians.

RotationMatrix[θ,w] gives the 3D rotation matrix for a counterclockwise rotation around the 3D vector w.

RotationMatrix[{u,v}] gives the matrix that rotates the vector u to the direction of the vector v in any dimension.

RotationMatrix[θ,{u,v}] gives the matrix that rotates by θ radians in the plane spanned by u and v.

RotationTransform

RotationTransform[θ] gives a TransformationFunction that represents a rotation in 2D by θ radians about the origin.

RotationTransform[θ,p] gives a 2D rotation about the 2D point p.

RotationTransform[θ,w] gives a 3D rotation around the direction of the 3D vector w.

RotationTransform[θ,w,p] gives a 3D rotation around the axis w anchored at the point p.

RotationTransform[{u,v}] gives a rotation about the origin that transforms the vector u to the direction of the vector v.

RotationTransform[{u,v},p] gives a rotation about the point p that transforms u to the direction of v.

RotationTransform[θ,{u,v},…] gives a rotation by θ radians in the plane spanned by u and v.

Round

Round[x] gives the integer closest to x. 

Round[x,a] rounds to the nearest multiple of a. 

RoundingRadius

RoundingRadius is an option for Rectangle, Framed and related functions that specifies the radius of the circle to use in rendering rounded corners.

Row

Row[{expr1,expr2,…}] is an object that formats with the expri arranged in a row, potentially extending over several lines. 

Row[list,s] inserts s as a separator between successive elements. 

RowReduce

RowReduce[m] gives the row‐reduced form of the matrix m. 

RSolve

RSolve[eqn,a[n],n] solves a recurrence equation for a[n]. 

RSolve[{eqn1,eqn2,…},{a1[n],a2[n],…},n] solves a system of recurrence equations. 

RSolve[eqn,a[n1,n2,…],{n1,n2,…}] solves a partial recurrence equation. 

RSolveValue

RSolveValue[eqn,expr,n] gives the value of expr determined by a symbolic solution to the ordinary difference equation eqn with independent variable n. 

RSolveValue[{eqn1,eqn2,…},expr,…] uses a symbolic solution for a list of difference equations. 

RSolveValue[eqn,expr,{n1,n2,…}] uses a solution for the partial recurrence equation eqn. 

RudinShapiro

RudinShapiro[n] gives the nth term in the Rudin–Shapiro sequence.

RudvalisGroupRu

RudvalisGroupRu[] represents the sporadic simple Rudvalis group Ru.

Rule

lhs->rhs or lhs->rhs represents a rule that transforms lhs to rhs. 

RuleCondition

RuleCondition is an internal symbol.

RuleDelayed

lhs:>rhs or lhsrhs represents a rule that transforms lhs to rhs, evaluating rhs only after the rule is used. 

RulePlot

RulePlot[sys] generates a plot representing the rule for the computational system sys.

RulePlot[sys,init,t] generates a plot of the evolution of the system sys from initial condition init for t steps.

RulePlot[sys,evol] generates a plot of the evolution evol assuming it is derived from a system of the form sys.

RulerUnits

RulerUnits is an option for notebooks that specifies the units in the ruler toolbar.

RulesTree

RulesTree[data->{rule1,rule2,…}] gives a tree whose root contains data and that has children specified by the rulei.

Run

Run["command"] runs command as an external operating system command, returning the exit code obtained.

RunProcess

RunProcess["command"] runs the specified external command, returning information on the outcome.

RunProcess[{"command", arg 1, arg 2, …}] runs the specified command, with command-line arguments arg i.

RunProcess[command, "prop"] returns only the specified property.

RunProcess[command, prop, input] feeds the specified initial input to the command.

RunScheduledTask

RunScheduledTask[expr] schedules and starts a local scheduled task that will repeatedly evaluate expr once per second.

RunScheduledTask[expr,time] schedules and starts a task that will repeatedly evaluate expr every time seconds.

RunScheduledTask[expr,{time}] schedules and starts a task that will evaluate expr once after time seconds.

RunScheduledTask[expr,{time,count}] schedules and starts a task that will try evaluating expr once every time seconds up to count times.

RunScheduledTask[expr,timespec,start] schedules a task that will automatically start at start time.

RunScheduledTask[CloudObject[…]] asynchronously executes an existing cloud task or document generator.

RunThrough

RunThrough["command",expr] executes an external command, giving the printed form of expr as input and taking the output, reading it as Wolfram Language input, and returning the result. 

RuntimeAttributes

RuntimeAttributes is an option for Compile that specifies attributes for the compiled function it creates.

RuntimeOptions

RuntimeOptions is an option for Compile that specifies runtime settings for the compiled function it creates.

RussellRaoDissimilarity

RussellRaoDissimilarity[u,v] gives the Russell–Rao dissimilarity between Boolean vectors u and v.

SameQ

lhs===rhs yields True if the expression lhs is identical to rhs, and yields False otherwise. 

SameTest

SameTest is an option whose setting gives a pairwise comparison function to determine whether expressions should be considered the same.

SameTestProperties

SameTestProperties is an option for set operations on entity classes whose setting gives the properties that are used to decide whether two given entities are the same.

SampledEntityClass

SampledEntityClass[class,n] represents an entity class containing n entities from class.

SampledEntityClass[class,{m,n}] represents an entity class containing entities m through n of class.

SampleDepth

SampleDepth is an option for sound primitives that specifies how many bits should be used to encode sound amplitude levels. 

SampledSoundFunction

SampledSoundFunction[f,n,r] is a sound primitive that represents a sound whose amplitude sampled r times a second is generated by applying the function f to successive integers from 1 to n. 

SampledSoundList

SampledSoundList[{a1,a2,…},r] is a sound primitive that represents a sound whose amplitude has levels ai sampled r times a second. 

SampleRate

SampleRate is an option that specifies the number of samples per second for sound and signal processing functions.

SamplingPeriod

SamplingPeriod is an option to StateSpaceModel etc. that specifies the sampling period.

SARIMAProcess

SARIMAProcess[{a1,…,ap},d,{b1,…,bq},{s,{α1,…,αm},δ,{β1,…,βr}},v] represents a seasonal integrated autoregressive moving-average process with ARIMA coefficients ai, d, and bj; seasonal order s; seasonal ARIMA coefficients αi, δ, and βj; seasonal integration order δ; and normal white noise with variance v.

SARIMAProcess[{a1,…,ap},d,{b1,…,bq},{s,{α1,…,αm},δ,{β1,…,βr}},Σ] represents a vector SARIMA process with coefficient matrices ai, bj, αi, and βj and covariance matrix Σ. 

SARIMAProcess[{a1,…},{d1,…},{b1,…},{{s1,…},{α1,…},{δ1,…},{β1,…}},Σ] represents a vector SARIMA process with multiple integration orders di, seasonal orders sj, and seasonal integration orders δk. 

SARIMAProcess[{a1,…,ap},d,{b1,…,bq},{s,{α1,…,αm},δ,{β1,…,βr}},v,init] represents a SARIMA process with initial data init. 

SARIMAProcess[c,…] represents a SARIMA process with constant c.

SARMAProcess

SARMAProcess[{a1,…,ap},{b1,…,bq},{s,{α1,…,αm},{β1,…,βr}},v] represents a weakly stationary seasonal autoregressive moving-average process with ARMA coefficients ai and bj, seasonal order s, seasonal ARMA coefficients αi and βj, and normal white noise with variance v.

SARMAProcess[{a1,…,ap},{b1,…,bq},{s,{α1,…,αm},{β1,…,βr}},Σ]  represents a weakly stationary vector SARMA process driven by normal white noise, with covariance matrix Σ.

SARMAProcess[{a1,…,ap},{b1,…,bq},{{s1,…},{α1,…,αm},{β1,…,βr}},Σ] represents a weakly stationary vector SARMA process with multiple seasonal orders si.

SARMAProcess[{a1,…,ap},{b1,…,bq},{s,{α1,…,αm},{β1,…,βr}},v,init]  represents a SARMA process with initial data init. 

SARMAProcess[c,…] represents a SARMA process with a constant c.

SASTriangle

SASTriangle[a,γ,b] returns a filled triangle with sides of length a and b and angle γ between them. 

SatelliteData

SatelliteData[entity,property] gives the value of the specified property for the satellite entity.

SatelliteData[{entity1,entity2,…},property] gives a list of property values for the specified satellite entities.

SatelliteData[entity,property,annotation] gives the specified annotation associated with the given property.

SatisfiabilityCount

SatisfiabilityCount[bf] counts the number of possible combinations of variable values that yield True when supplied as arguments to the Boolean function bf.

SatisfiabilityCount[expr,{a1,a2,…}] counts the number of possible combinations of the ai that make the Boolean expression expr be true.

SatisfiabilityInstances

SatisfiabilityInstances[bf] attempts to find a choice of variables that makes the Boolean function bf yield True.

SatisfiabilityInstances[expr,{a1,a2,…}] attempts to find a choice of the ai that makes the Boolean expression expr be True.

SatisfiabilityInstances[…,…,m] attempts to find m choices of variables that yield True.

SatisfiableQ

SatisfiableQ[bf] gives True if a combination of values of variables exists that makes the Boolean function bf yield True.

SatisfiableQ[expr,{a1,a2,…}] gives True if a combination of values of the ai exists that makes the Boolean expression expr yield True.

Saturday

Saturday is a day of the week.

Save

Save["filename",symbol] appends definitions associated with the specified symbol to a file. 

Save["filename","patt"] appends definitions associated with all symbols whose names match the string pattern "patt". 

Save["filename","context`"] appends definitions associated with all symbols in the specified context. 

Save["filename",{object1,object2,…}] appends definitions associated with several objects. 

Saveable

Saveable is an option for notebooks that specifies whether a notebook can be saved.

SaveConnection

SaveConnection is an option for ServiceConnect that determines whether the connection should be saved in the authenticated user's account.

SaveDefinitions

SaveDefinitions is an option to Manipulate and related functions that specifies whether current definitions relevant for the evaluation of the expression being manipulated should automatically be saved.

SawtoothWave

SawtoothWave[x] gives a sawtooth wave that varies from 0 to 1 with unit period.

SawtoothWave[{min,max},x] gives a sawtooth wave that varies from min to max with unit period.

Scale

Scale[g,s] represents graphics primitives g scaled by a factor s. 

Scale[g,s,{x,y,…}] scales with the point {x,y,…} kept fixed. 

Scale[g,{sx,sy,…},…] scales by different factors along different axes. 

Scaled

Scaled[{x,y,…}] gives the position of a graphical object in terms of coordinates scaled to run from 0 to 1 across the whole plot range in each direction. 

Scaled[{dx,dy,…},{x0,y0,…}] gives a position obtained by starting at ordinary coordinates {x0,y0,…}, then moving by a scaled offset {dx,dy,…}. 

ScaleDivisions

ScaleDivisions is an option for gauge functions that specifies how many tick marks should be drawn on the scale.

ScaleOrigin

ScaleOrigin is an option for gauge functions that describes how to position the scale on the gauge.

ScalePadding

ScalePadding is an option for gauge functions that specifies how much space to leave around the scale.

ScaleRanges

ScaleRanges is an option for gauge functions that describes how to draw sections of the scale.

ScaleRangeStyle

ScaleRangeStyle is an option for gauge functions to describe how to style different sections of the scale.

ScalingFunctions

ScalingFunctions is an option for ListPlot, BarChart, Histogram, and other plotting functions that specifies what scaling functions should be used. 

ScalingMatrix

ScalingMatrix[{sx,sy,…}] gives the matrix corresponding to scaling by a factor si along each coordinate axis.

ScalingMatrix[s,v] gives the matrix corresponding to scaling by a factor s along the direction of the vector v.

ScalingTransform

ScalingTransform[{sx,sy,…}] gives a TransformationFunction that represents scaling by a factor si along each coordinate axis from the origin.

ScalingTransform[{sx,sy,…},p] gives scaling centered at the point p.

ScalingTransform[s,v] gives scaling by a factor s along the direction of the vector v.

ScalingTransform[s,v,p] gives scaling along the direction of v, centered at the point p.

Scan

Scan[f,expr] evaluates f applied to each element of expr in turn. 

Scan[f,expr,levelspec] applies f to parts of expr specified by levelspec. 

Scan[f] represents an operator form of Scan that can be applied to an expression.

ScheduledTask

ScheduledTask[expr,timespec] represents a scheduled task to be evaluated on the schedule defined by timespec.

ScheduledTaskActiveQ

ScheduledTaskActiveQ[obj] yields True if obj represents an active task, and False otherwise.

ScheduledTaskInformation

ScheduledTaskInformation[cloudobj] returns the properties of the ScheduledTask cloudobj.

ScheduledTaskInformation[cloudobj,property] returns the value of the property property.

ScheduledTaskObject

ScheduledTaskObject[id,expr,spec,…] is a task object specifying future evaluation of expr according to spec.

ScheduledTasks

ScheduledTasks[] returns a list of ScheduledTaskObject and CloudObject expressions that represent current tasks.

SchurDecomposition

SchurDecomposition[m] yields the Schur decomposition for a numerical matrix m, given as a list {q,t} where q is an orthonormal matrix and t is a block upper‐triangular matrix. 

SchurDecomposition[{m,a}] gives the generalized Schur decomposition of m with respect to a. 

ScientificForm

ScientificForm[expr] prints with all real numbers in expr given in scientific notation. 

ScientificForm[expr,n] prints with numbers given to n‐digit precision. 

ScientificNotationThreshold

ScientificNotationThreshold is an option for NumberForm and related functions that specifies the threshold between the use of decimal notation and scientific notation to represent real numbers.

ScorerGi

ScorerGi[z] gives the Scorer function Gi(z).

ScorerGiPrime

ScorerGiPrime[z] gives the derivative of the Scorer function Gi′(z).

ScorerHi

ScorerHi[z] gives the Scorer function Hi(z).

ScorerHiPrime

ScorerHiPrime[z] gives the derivative of the Scorer function Hi′(z).

ScreenRectangle

ScreenRectangle is a global option that specifies the position of the primary screen by giving the coordinates of two diagonally opposite corners.

ScreenStyleEnvironment

ScreenStyleEnvironment is an option for notebooks that specifies the style environment to be used in displaying a notebook on the screen. 

ScriptBaselineShifts

ScriptBaselineShifts is an option for Style that specifies the minimum distance in x‐heights to shift subscripts and superscripts. 

ScriptLevel

ScriptLevel is an option for selections that is used in determining the font size of modifiers such as subscripts and superscripts in a nested expression.

ScriptMinSize

ScriptMinSize is an option for Style which specifies the minimum font size to use in rendering subscripts, etc. 

ScriptSizeMultipliers

ScriptSizeMultipliers is an option for Style that specifies how much smaller to render each successive level of subscripts, etc. 

Scrollbars

Scrollbars is an option for Pane that specifies whether scrollbars should be displayed.

ScrollingOptions

ScrollingOptions is an option for notebooks that specifies settings for scrolling.

ScrollPosition

ScrollPosition is an option for Pane that specifies the scroll position of the contents of the pane.

SearchAdjustment

SearchAdjustment[query,w] represents a component of a search query that is to be treated as having weight w.

SearchAdjustment[query,…,opts] represents a component of a search query with certain options.

SearchIndexObject

SearchIndexObject[loc] represents a search index object, as created by CreateSearchIndex.

SearchIndexObject["name"] represents the search index with the specified name in the SearchIndices[] list.

SearchIndices

SearchIndices[] returns a list with all the locally stored instances of SearchIndexObject.

SearchQueryString

SearchQueryString["query"] represents a search engine-style query in TextSearch and related functions.

SearchResultObject

SearchResultObject[…] represents a result from TextSearch[…] and related functions.

Sec

Sec[z] gives the secant of z. 

Sech

Sech[z] gives the hyperbolic secant of z. 

SechDistribution

SechDistribution[μ,σ] represents the hyperbolic secant distribution with location parameter μ and scale parameter σ.

SechDistribution[] represents the hyperbolic secant distribution with location parameter 0 and scale parameter 1.

SecondOrderConeOptimization

SecondOrderConeOptimization[f,cons,vars] finds values of variables vars that minimize the linear objective f subject to second-order cone and/or linear constraints cons.

SecondOrderConeOptimization[c,{{a1,b1,α1,β1},…,{ak,bk,αk,βk}}] finds a vector x that minimizes c.x subject to the constraints ai.x+bi≤αi.x+βi.

SecondOrderConeOptimization[c,…,{dom1,dom2,…}] takes xi to be in the domain domi, where domi is Integers or Reals. 

SecondOrderConeOptimization[…,"prop"] specifies what solution property "prop" should be returned.

SectorChart

SectorChart[{{x1,y1},{x1,y2},…}] makes a sector chart with sector angles proportional to xi and radii yi.

SectorChart[{…,wi[{xi,yi},…],…,wj[{xj,yj},…],…}] makes a sector chart with sector features defined by the symbolic wrappers wk.

SectorChart[{data1,data2,…}] makes a sector chart from multiple datasets datai.

SectorChart3D

SectorChart3D[{{x1,y1,z1},{x2,y2,z2},…}] makes a 3D sector chart with sector angle proportional to xi, radius yi, and height zi.

SectorChart3D[{…,wi[{xi,yi,zi},…],…,wj[{xj,yj,zj},…],…}] makes a 3D sector chart with sector features defined by the symbolic wrappers wk.

SectorChart3D[{data1,data2,…}] makes a 3D sector chart from multiple datasets datai. 

SectorOrigin

SectorOrigin is an option to PieChart and related functions that specifies where sectors should start.

SectorSpacing

SectorSpacing is an option to PieChart and related functions that specifies radial spacing of sectors. 

SecuredAuthenticationKey

SecuredAuthenticationKey[assoc] represents a secured authentication key with credentials and details specified by the association assoc.

SecuredAuthenticationKeys

SecuredAuthenticationKeys[] retrieves a list of all instances of SecuredAuthenticationKey owned by the currently connected user. 

SecuredAuthenticationKeys["name"] retrieves a SecuredAuthenticationKey identified by "name" owned by the currently connected user, if it exists.

SecurityCertificate

SecurityCertificate[assoc] represents the security certificate issued for a public key.

SeedRandom

SeedRandom[s] resets the pseudorandom generator, using s as a seed. 

SeedRandom[] resets the generator, using as a seed the time of day and certain attributes of the current Wolfram System session. 

Select

Select[data,crit] picks out all elements ei of data for which crit[ei] is True. 

Select[data,crit->prop] returns the property prop of the selected elements.

Select[data,crit,n] picks out the first n elements for which crit[ei] is True. 

Select[crit] represents an operator form of Select that can be applied to an expression. 

SelectComponents

SelectComponents[{image,lmat},crit] selects components of image indicated by the label matrix lmat that satisfy crit, replacing other parts with black.

SelectComponents[image,crit] selects connected components of image.

SelectComponents[…,"prop",n] computes the property "prop" and selects the first n in sorted order.

SelectComponents[…,"prop",n,p] sorts computed properties using the ordering function p.

SelectedCells

SelectedCells[notebook] returns a list of CellObject expressions corresponding to the currently selected cells in notebook.

SelectedCells[] returns the currently selected cells in the notebook in which this function is being evaluated.

SelectFirst

SelectFirst[data,crit] gives the first ei of data for which crit[ei] is True, or Missing["NotFound"] if none is found.

SelectFirst[data,crit->prop] returns the property prop of the selected elements.

SelectFirst[data,crit,default] gives default if there is no ei of data such that crit[ei] is True.

SelectFirst[crit] represents an operator form of SelectFirst that can be applied to an expression.

SelfLoopStyle

SelfLoopStyle is an option for GraphPlot and related functions that specifies how to draw self-loops that connect a vertex to itself.

SemanticImport

SemanticImport[file] attempts to import a file semantically to give a Dataset object.

SemanticImport[file,type] attempts to interpret all elements in the file as being of the specified type.

SemanticImport[file,{type1,type2,…}] attempts to interpret elements in successive columns as being of the specified types. 

SemanticImport[file,<|col1->type1,col2->type2,…|>] keeps only the columns coli specified by their positions or names.

SemanticImport[file,typespec,form] puts the result in the specified form.

SemanticImportString

SemanticImportString["string"] attempts to import a string semantically to give a Dataset object.

SemanticImportString["string",type] attempts to interpret all elements in the string as being of the specified type.

SemanticImportString["string",{type1,type2,…}] attempts to interpret elements in successive columns as being of the specified types. 

SemanticImportString["string",<|col1->type1,col2->type2,…|>] attempts to interpret elements in the named columns as being of the specified types.

SemanticImportString["string",typespec,form] puts the result in the specified form.

SemanticInterpretation

SemanticInterpretation["string"] attempts to give the best semantic interpretation of the specified free-form string as a Wolfram Language expression.

SemanticInterpretation["string",pattern] filters possible semantic interpretations, returning the best one that matches the specified pattern.

SemanticInterpretation["string",pattern,head] returns the semantic interpretation wrapped with the specified head.

SemialgebraicComponentInstances

SemialgebraicComponentInstances[ineqs,{x1,x2,…}] gives at least one sample point in each connected component of the semialgebraic set defined by the inequalities ineqs in the variables x1, x2, ….

SendMail

SendMail[body] sends mail consisting of body to the address specified by $CloudUserID.

SendMail[{"subject"}] sends mail with the specified subject and no body.

SendMail[{"subject",body}] sends mail with the specified subject and body.

SendMail[{"subject",body,att}] sends mail with the attachment or attachments att.

SendMail["to",content] sends mail to the specified To: address.

SendMail[{to1,to2,…},content] sends mail to multiple To: addresses.

SendMail[{{to1,…},{cc1,…}},content] includes the cci as Cc: addresses.

SendMail[{{to1,…},{cc1,…},{bcc1,…}},content] also includes the bcci as Bcc: addresses.

SendMail[assoc] sends mail with elements specified in the association assoc.

SendMessage

SendMessage[channel,message] sends a message to the specified channel.

SendMessage[channel->dest,message] sends a message to the destination dest through the specified channel.

Sequence

Sequence[expr1,expr2,…] represents a sequence of arguments to be spliced automatically into any function. 

SequenceAlignment

SequenceAlignment[s1,s2] finds an optimal alignment of sequences of elements in the strings, lists or biomolecular sequences s1 and s2, and yields a list of successive matching and differing sequences.

SequenceAttentionLayer

SequenceAttentionLayer[] is equivalent to AttentionLayer[] with a single "Input" port instead of ports "Key" and "Value". It should no longer be used.

SequenceAttentionLayer[net] is equivalent to AttentionLayer[net] with a single "Input" port instead of ports "Key" and "Value". It should no longer be used.

SequenceCases

SequenceCases[list,patt] gives a list of the sublists in list that match the sequence pattern patt.

SequenceCases[list,patt->rhs] gives a list of the values of rhs corresponding to sublists that match patt.

SequenceCases[list,patt,n] includes only the first n matches.

SequenceCount

SequenceCount[list,sub] gives a count of the number of times sub appears as a sublist of list.

SequenceCount[list,patt] gives the number of sublists in list that match the general sequence pattern patt. 

SequenceFold

SequenceFold[f,{x1,…,xn},{a1,a2,…}] gives the last element of SequenceFoldList[f,{x1,…,xn},{a1,a2,…}].

SequenceFold[f,{x1,…,xn},{a1,a2,…},k] applies f to k arguments at each step, with the first n coming from the xi or previous results, and the last k-n coming from the ai.

SequenceFoldList

SequenceFoldList[f,{x1,…,xn},{a1,a2,…}] gives {x1,…,xn,f[x1,…,xn,a1],f[x2,…,xn,f[x1,…,xn,a1],a2],…}.

SequenceFoldList[f,{x1,…,xn},{a1,a2,…},k] applies f to k arguments at each step, with the first n coming from the xi or previous results, and the last k-n coming from the ai. 

SequenceForm

SequenceForm[expr1,expr2,…] prints as the textual concatenation of the printed forms of the expri. 

SequenceHold

SequenceHold is an attribute that specifies that Sequence objects appearing in the arguments of a function should not automatically be flattened out. 

SequenceIndicesLayer

SequenceIndicesLayer[] represents a net layer that produces a list of indices for an input sequence.

SequenceLastLayer

SequenceLastLayer[] represents a net that takes a sequence of inputs and returns the last element of the sequence.

SequenceMostLayer

SequenceMostLayer[] represents a net that takes a sequence of inputs and removes its last element.

SequencePosition

SequencePosition[list,sublist] gives a list of the starting and ending positions at which sublist appears in list.

SequencePosition[list,patt] gives all positions at which sequences matching patt occur in list.

SequencePosition[list,patt,n] includes only the first n occurrences of patt.

SequencePredict

SequencePredict[{seq1,seq2,…}] generates a SequencePredictorFunction[…] based on the sequences given.

SequencePredict[training,seq] attempts to predict the next element in the sequence seq from the training sequences given.

SequencePredict[training,{seq1,seq2,…}] gives predictions for each of the sequences seqi.

SequencePredict["name",seq] uses the built-in sequence predictor represented by "name".

SequencePredict[…,seq,prop] give the specified property of the prediction associated with seq.

SequencePredictorFunction

SequencePredictorFunction[…] represents a function generated by SequencePredict that predicts the next elements from a sequence.

SequenceReplace

SequenceReplace[list,rules] replaces sequences in list according to the specified rule or list of rules. 

SequenceReplace[list,rules,n] does only the first n replacements.

SequenceReplace[rules] represents an operator form of SequenceReplace that can be applied to an expression.

SequenceRestLayer

SequenceRestLayer[] represents a net that takes a sequence of inputs and removes its first element.

SequenceReverseLayer

SequenceReverseLayer[] represents a net that reverses the order of an input sequence.

SequenceSplit

SequenceSplit[list,patt] splits list into sublists separated by sequences that match the sequence pattern patt. 

SequenceSplit[list,patt->rhs] inserts rhs at the position of each matched sequence.

SequenceSplit[list,{patt1->rhs1,…}] inserts rhsi at the position of each patti.

SequenceSplit[list,patt,n] splits into at most n sublists.

SeriesCoefficient

SeriesCoefficient[series,n] finds the coefficient of the nth-order term in a power series in the form generated by Series. 

SeriesCoefficient[f,{x,x0,n}] finds the coefficient of (x-x0)n in the expansion of f about the point x=x0.

SeriesCoefficient[f,{x,x0,nx},{y,y0,ny},…] finds a coefficient in a multivariate series. 

SeriesData

SeriesData[x,x0,{a0,a1,…},nmin,nmax,den] represents a power series in the variable x about the point x0. The ai are the coefficients in the power series. The powers of (x-x0) that appear are nmin/den, (nmin+1)/den, …, nmax/den. 

SeriesTermGoal

SeriesTermGoal is an option for Asymptotic, DiscreteAsymptotic and similar functions that specifies the number of desired terms in an asymptotic approximation.

ServiceConnect

ServiceConnect["service"] creates a connection to an external service.

ServiceConnect["service",id] uses the specified connection identifier.

ServiceDisconnect

ServiceDisconnect[service] disconnects from an external service specified by a ServiceObject.

ServiceExecute

ServiceExecute[service,"req"] executes "req" on an external service.

ServiceExecute[service,"req",{par1->val1,…}] executes "req" with the specified settings for parameters.

ServiceExecute[req] executes ServiceRequest req on an external service.

ServiceObject

ServiceObject["service",…] represents an open connection to an external service.

ServiceRequest

ServiceRequest[service,"req"] represents a service request built from service, which might be a connected ServiceObject or a valid service name, and request "req".

ServiceRequest[service,"req",param] represents a service request, built from the service service, request "req" and parameters param.

ServiceRequest[assoc] represents a service request, built from association assoc.

ServiceSubmit

ServiceSubmit[ServiceRequest[assoc]] submits a request to be executed by an external service specified by assoc.

ServiceSubmit[ScheduledTask[req,spec]] submits a task to evaluate ServiceRequest req on an external service following the schedule defined by spec.

ServiceSubmit[ContinuousTask[req,spec]] submits a task to evaluate ServiceRequest req on an external service; the result of the request is updated whenever available.

SessionSubmit

SessionSubmit[expr] submits an asynchronous task to evaluate expr in the current session.

SessionSubmit[ScheduledTask[expr,spec]] submits a task to evaluate expr in the current session on the schedule defined by spec.

SessionTime

SessionTime[] gives the total number of seconds of real time that have elapsed since the beginning of your Wolfram System session. 

Set

lhs=rhs evaluates rhs and assigns the result to be the value of lhs. From then on, lhs is replaced by rhs whenever it appears. 

{l1,l2,…}={r1,r2,…} evaluates the ri, and assigns the results to be the values of the corresponding li. 

SetAccuracy

SetAccuracy[expr,a] yields a version of expr in which all numbers have been set to have accuracy a. 

SetAlphaChannel

SetAlphaChannel[color] adds full opacity to color.

SetAlphaChannel[color,a] adds opacity a to color.

SetAlphaChannel[image,…] adds an alpha channel to image.

SetAlphaChannel[video,…] adds an alpha channel to the frames of video.

SetAttributes

SetAttributes[symbol,attr] adds attr to the list of attributes of the symbol symbol. 

SetAttributes["symbol",attr] adds attr to the attributes of the symbol named "symbol" if it exists.

SetAttributes[s,{attr1,attr2,…}] sets several attributes at a time.

SetAttributes[{s1,s2,…},attrs] sets attributes of several symbols at a time.

SetCookies

SetCookies[assoc] sets cookies with attributes specified by the association assoc, to be used by functions such as URLExecute.

SetCookies[{assoc1,assoc2,…}] sets a list of cookies.

SetDelayed

lhs:=rhs assigns rhs to be the delayed value of lhs. rhs is maintained in an unevaluated form. When lhs appears, it is replaced by rhs, evaluated afresh each time. 

SetDirectory

SetDirectory["dir"] sets the current working directory to dir. 

SetDirectory[] sets the current working directory to your "home" directory.

SetEnvironment

SetEnvironment["var"->value] sets the value of an operating system environment variable.

SetEnvironment[{"var"->value,…}] sets values for several environment variables.

SetFileDate

SetFileDate["file"] sets the modification and access dates for a file to be the current date. 

SetFileFormatProperties

SetFileFormatProperties["fmt","prop"->val] sets the value of a property "prop" for the specified format "fmt".

SetFileFormatProperties["fmt",{prop1->val1,prop2->val2,…}] sets the value of multiple properties "propi".

SetOptions

SetOptions[s,name1->value1,name2->value2,…] sets the specified default options for a symbol s. 

SetOptions[stream,…] or SetOptions["name",…] sets options associated with a particular stream. 

SetOptions[object,…] sets options associated with an external object such as a NotebookObject or CloudObject. 

SetPrecision

SetPrecision[expr,p] yields a version of expr in which all numbers have been set to have precision p. 

SetProperty

SetProperty[{obj,itemspec},name->value] sets the property name->value for itemspec in obj.

SetSharedFunction

SetSharedFunction[f1,f2,…] declares the symbols fi as shared functions that are synchronized among all parallel kernels.

SetSharedVariable

SetSharedVariable[s1,s2,…] declares the symbols si as shared variables whose values are synchronized among all parallel kernels.

SetStreamPosition

SetStreamPosition[stream,n] sets the current point in an open stream. 

Shallow

Shallow[expr] prints as a shallow form of expr. 

Shallow[expr,depth] prints with all parts of expr below the specified depth given in skeleton form. 

Shallow[expr,{depth,length}] also gives parts whose lengths are above the specified limit in skeleton form. 

Shallow[expr,{depth,length},form] uses skeleton form for any parts that match the pattern form. 

ShannonWavelet

ShannonWavelet[] represents the Shannon wavelet evaluated on the equally spaced interval {-10,10}. 

ShannonWavelet[lim] represents the Shannon wavelet evaluated on the equally spaced interval {-lim,lim}. 

ShapiroWilkTest

ShapiroWilkTest[data] tests whether data is normally distributed using the Shapiro–Wilk test.

ShapiroWilkTest[data,"property"] returns the value of "property".

Share

Share[expr] changes the way expr is stored internally, to try and minimize the amount of memory used. 

Share[] tries to minimize the memory used to store all expressions. 

SharingList

SharingList is an option for CloudObject and related constructs that specifies with whom the object has been shared.

Sharpen

Sharpen[image] gives a sharpened version of image.

Sharpen[image,r] gives a version of image sharpened over pixel radius r.

ShearingMatrix

ShearingMatrix[θ,v,n] gives the matrix corresponding to shearing by θ radians along the direction of the vector v, and normal to the vector n. 

ShearingTransform

ShearingTransform[θ,v,n] gives a TransformationFunction that represents a shear by θ radians along the direction of the vector v, normal to the vector n, and keeping the origin fixed.

ShearingTransform[θ,v,n,p] gives a shear that keeps the point p fixed, rather than the origin.

ShellRegion

ShellRegion[reg] gives a solid shell of a 3D region reg.

ShellRegion[reg,t] gives a solid shell of reg with minimal thickness t.

ShiftedGompertzDistribution

ShiftedGompertzDistribution[λ,ξ] represents a shifted Gompertz distribution with scale parameter λ and shape parameter ξ.

ShiftRegisterSequence

ShiftRegisterSequence[n] gives a complete maximum-length sequence for a size n linear-feedback shift register.

ShiftRegisterSequence[{n,{tap1,tap2,…}}] gives the complete sequence for a linear-feedback shift register with size n and taps at positions tapi.

ShiftRegisterSequence[poly] gives the sequence for a linear-feedback shift register with feedback polynomial poly.

ShiftRegisterSequence[{n,{tap1,tap2,…},f}] gives the sequence for a shift register with feedback function f.

ShiftRegisterSequence[spec,s] gives the first s elements of the shift register sequence.

ShiftRegisterSequence[spec,init,s] gives the shift register sequence starting from state init.

Short

Short[expr] prints as a short form of expr, less than about one line long. 

Short[expr,n] prints as a form of expr about n lines long. 

ShortDownArrow

ShortDownArrow[x,y,…] displays as xy….

Shortest

Shortest[p] is a pattern object that matches the shortest sequence consistent with the pattern p. 

ShortestMatch

ShortestMatch[p] is a string pattern object matching the shortest sequence of characters consistent with the string pattern p.

ShortestPathFunction

ShortestPathFunction[type,data] represents a function that gives the shortest path from a source vertex s to target vertex t in a graph.

ShortLeftArrow

ShortLeftArrow[x,y,…] displays as xy….

ShortRightArrow

ShortRightArrow[x,y,…] displays as xy….

ShortTimeFourier

ShortTimeFourier[data] returns the short-time Fourier transform (STFT) of data as a ShortTimeFourierData object.

ShortTimeFourier[data,n] uses partitions of length n.

ShortTimeFourier[data,n,d] uses partitions with offset d.

ShortTimeFourier[data,n,d,wfun] applies a smoothing window wfun to each partition.

ShortTimeFourier[data,n,d,wfun,m] pads partitions with zeros to length m prior to the computation of the transform.

ShortTimeFourierData

ShortTimeFourierData[assoc] represents the result and properties of a short-time Fourier transform (STFT) of a signal.

ShortUpArrow

ShortUpArrow[x,y,…] displays as xy….

Show

Show[graphics,options] shows graphics with the specified options added. 

Show[g1,g2,…] shows several graphics combined. 

ShowAutoSpellCheck

ShowAutoSpellCheck is an option for Cell that specifies whether to highlight misspelled words.

ShowAutoStyles

ShowAutoStyles is an option for Cell that specifies whether styles that are specified to be automatically used for various syntactic and other constructs should be shown. 

ShowCellBracket

ShowCellBracket is an option for Cell that specifies whether to display the bracket that indicates the extent of the cell. 

ShowCursorTracker

ShowCursorTracker is an option for Cell that specifies whether an elliptical spot should appear momentarily to guide the eye if the cursor position jumps. 

ShowPageBreaks

ShowPageBreaks is a notebook option that specifies whether to indicate in the on‐screen display of a notebook where page breaks would occur if the notebook were printed. 

ShrinkingDelay

ShrinkingDelay is an option for dynamic objects that specifies how long to delay before shrinking the size of the region in which the object is displayed to the actual size of the object. 

SiderealTime

SiderealTime[] gives the right ascension of the local meridian for the current date and location.

SiderealTime[date] gives the right ascension of the local meridian for the specified date.

SiderealTime[loc] gives the right ascension of the local meridian for the specified location.

SiderealTime[loc,date] gives the right ascension of the local meridian for the specified date and location.

SiderealTime[{{loc1,date1},{loc2,date2},…}] gives the right ascensions of the local meridians for all specified locations on the specified dates.

SiderealTime[loc,date,func] uses func to determine what to return for extended locations.

SiderealTime["MeanTime",loc,date,func] gives the mean sidereal time for the specified date, location and aggregation function.

SiegelTheta

SiegelTheta[Ω,s] gives the Siegel theta function Θ (Ω,s) with Riemann modular matrix Ω and vector s.

SiegelTheta[{ν1,ν2},Ω,s] gives the Siegel theta function Θ [ν1,ν2]( Ω,s) with characteristics ν1 and ν2.

SierpinskiCurve

SierpinskiCurve[n] gives the line segments representing the nth-step Sierpiński curve.

SierpinskiMesh

SierpinskiMesh[n] gives a mesh region representing the nth-step Sierpiński triangle. 

SierpinskiMesh[n,d] gives the nth-step Sierpiński sponge in dimension d.

Sign

Sign[x] gives -1, 0, or 1 depending on whether x is negative, zero, or positive. 

Signature

Signature[list] gives the signature of the permutation needed to place the elements of list in canonical order. 

SignedRankTest

SignedRankTest[data] tests whether the median of data is zero. 

SignedRankTest[{data1,data2}] tests whether the median of data1-data2 is zero.

SignedRankTest[dspec,μ0] tests a location measure against μ0.

SignedRankTest[dspec,μ0,"property"] returns the value of "property".

SignedRegionDistance

SignedRegionDistance[reg,p] gives the minimum distance from the point p to the region reg if p is outside the region and the minimum distance to the complement of reg if p is inside the region.

SignedRegionDistance[reg] gives a RegionDistanceFunction[…] that can be applied repeatedly to different points.

SignificanceLevel

SignificanceLevel is an option to VarianceTest and similar functions that controls cutoffs for diagnostic tests as well as test conclusions. 

SignPadding

SignPadding is an option for NumberForm and related functions that specifies whether padding should be inserted after signs. 

SignTest

SignTest[data] tests whether the median of data is zero. 

SignTest[{data1,data2}] tests whether the median of data1– data2 is zero.

SignTest[dspec,μ0] tests a location measure against μ0.

SignTest[dspec,μ0,"property"] returns the value of "property".

SimilarityRules

SimilarityRules is an option for functions such as SequenceAlignment that gives a list of rules for similarity scores to assume between pairs of elements.

SimpleGraph

SimpleGraph[g] gives the underlying simple graph from the graph g.

SimpleGraph[{v->w,…}] uses rules v->w to specify the graph g.

SimpleGraphQ

SimpleGraphQ[g] yields True if the graph g is a simple graph and False otherwise.

SimplePolygonQ

SimplePolygonQ[poly] gives True if the polygon poly is simple and False otherwise.

SimplePolyhedronQ

SimplePolyhedronQ[poly] gives True if the polyhedron poly is simple and False otherwise.

Simplex

Simplex[{p1,…,pk}] represents the simplex spanned by points pi.

Simplify

Simplify[expr] performs a sequence of algebraic and other transformations on expr and returns the simplest form it finds. 

Simplify[expr,assum] does simplification using assumptions. 

Sin

Sin[z] gives the sine of z. 

Sinc

Sinc[z] gives sinc(z). 

SinghMaddalaDistribution

SinghMaddalaDistribution[q,a,b] represents the Singh–Maddala distribution with shape parameters q and a and scale parameter b.

SingleLetterItalics

SingleLetterItalics is an option for Cell that specifies whether single‐letter names should be displayed in italics. 

SingularValueDecomposition

SingularValueDecomposition[m] gives the singular value decomposition for a numerical matrix m as a list of matrices {u,σ,v}, where σ is a diagonal matrix and m can be written as u.σ.ConjugateTranspose[v].

SingularValueDecomposition[{m,a}] gives the generalized singular value decomposition of m with respect to a. 

SingularValueDecomposition[m,k] gives the singular value decomposition associated with the k largest singular values of m. 

SingularValueDecomposition[m,UpTo[k]] gives the decomposition for the k largest singular values, or as many as are available. 

SingularValueList

SingularValueList[m] gives a list of the nonzero singular values of a matrix m. 

SingularValueList[{m,a}] gives the generalized singular values of m with respect to a. 

SingularValueList[m,k] gives the k largest singular values of m. 

SingularValueList[{m,a},k] gives the k largest generalized singular values of m.

SingularValuePlot

SingularValuePlot[lsys] generates a plot of the singular values of the transfer function for the system lsys. 

SingularValuePlot[lsys,{ωmin,ωmax}] plots for the frequency range ωmin to ωmax.

SingularValuePlot[expr,{ω,ωmin,ωmax}] plots expr using the variable ω.

SingularValues

SingularValues[m] gives the singular value decomposition for a numerical matrix m. The result is a list {u,w,v}, where w is the list of singular values, and m can be written as ConjugateTranspose[u]. DiagonalMatrix[w].v.

Sinh

Sinh[z] gives the hyperbolic sine of z. 

SinhIntegral

SinhIntegral[z] gives the hyperbolic sine integral function Shi(z). 

SinIntegral

SinIntegral[z] gives the sine integral function Si(z)=∫0zsin(t)/t dt. 

SixJSymbol

SixJSymbol[{j1,j2,j3},{j4,j5,j6}] gives the values of the Wigner 6‐j symbol. 

Skeleton

Skeleton[n] represents a sequence of n omitted elements in an expression printed with Short or Shallow. The standard print form for Skeleton is n. 

SkeletonTransform

SkeletonTransform[image] gives the skeleton transform of image, in which the value of each skeleton pixel is its distance to the nearest background pixel.

SkeletonTransform[image,t] treats values above t as foreground.

SkellamDistribution

SkellamDistribution[μ1,μ2] represents a Skellam distribution with shape parameters μ1 and μ2.

Skewness

Skewness[data] gives the coefficient of skewness estimate for the elements in data.

Skewness[dist] gives the coefficient of skewness for the distribution dist.

SkewNormalDistribution

SkewNormalDistribution[μ,σ,α] represents a skew-normal distribution with shape parameter α, location parameter μ, and scale parameter σ.

SkinStyle

SkinStyle is an option of AnatomyPlot3D that specifies what style to use for automatically included skin subparts.

Skip

Skip[stream,type] skips one object of the specified type in an input stream. 

Skip[stream,type,n] skips n objects of the specified type. 

SliceContourPlot3D

SliceContourPlot3D[f,surf,{x,xmin,xmax},{y,ymin,ymax},{z,zmin,zmax}] generates a contour plot of f over the slice surface surf as a function of x, y, and z.

SliceContourPlot3D[f,surf,{x,y,z}∈reg] restricts the surface to be within region reg.

SliceContourPlot3D[f,{surf1,surf2,…},…] generates contour plots over several slices. 

SliceDensityPlot3D

SliceDensityPlot3D[f,surf,{x,xmin,xmax},{y,ymin,ymax},{z,zmin,zmax}] generates a density plot of f over the slice surface surf as a function of x, y, and z.

SliceDensityPlot3D[f,surf,{x,y,z}∈reg] restricts the surface to be within region reg.

SliceDensityPlot3D[f,{surf1,surf2,…},…] generates density plots over several slices. 

SliceDistribution

SliceDistribution[proc,t] represents the distribution of the process state at time t.

SliceDistribution[proc,{t1,…,tk}] represents the joint distribution of process states at times t1<⋯<tk.

SliceVectorPlot3D

SliceVectorPlot3D[{vx,vy,vz},surf,{x,xmin,xmax},{y,ymin,ymax},{z,zmin,zmax}] generates a vector plot of the field {vx,vy,vz} over the slice surface surf. 

SliceVectorPlot3D[{vx,vy,vz},surf,{x,y,z}∈reg] restricts the surface surf to be within the region reg.

SliceVectorPlot3D[{vx,vy,vz},{surf1,surf2,…},…] generates vector plots over several slice surfaces surfi.

Slot

# represents the first argument supplied to a pure function. 

#n represents the nth argument. 

#name represents the value associated with key "name" in an association in the first argument. 

Small

Small is a style or option setting that specifies that objects should be small.

SmallCircle

SmallCircle[x,y,…] displays as x∘y∘….

Smaller

Smaller is a style or option setting that specifies that objects should be smaller.

SmithDecomposition

SmithDecomposition[m] gives the Smith normal form decomposition of an integer matrix m.

SmithDelayCompensator

SmithDelayCompensator[sys,con] gives the Smith compensator for the time-delay system sys and the delay-free controller con.

SmithWatermanSimilarity

SmithWatermanSimilarity[u,v] gives a number representing the Smith–Waterman similarity between strings or vectors u and v.

SmithWatermanSimilarity[u,v] gives a number representing the Smith–Waterman similarity between strings, vectors or bio sequences u and v.

SmoothDensityHistogram

SmoothDensityHistogram[{{x1,y1},{x2,y2},…}] plots a smooth kernel histogram of the values {xi,yi}.

SmoothDensityHistogram[{{x1,y1},{x2,y2},…},espec] plots a smooth kernel histogram with estimator specification espec.

SmoothDensityHistogram[{{x1,y1},{x2,y2},…},espec,dfun] plots the distribution function dfun.

SmoothHistogram

SmoothHistogram[{x1,x2,…}] plots a smooth kernel histogram for the PDF of the values xi.

SmoothHistogram[{x1,x2,…},espec] plots a smooth kernel histogram with estimator specification espec.

SmoothHistogram[{x1,x2,…},espec,dfun] plots the distribution function dfun. 

SmoothHistogram[{data1,data2,…},…] plots smooth kernel histograms for multiple datasets datai.

SmoothHistogram3D

SmoothHistogram3D[{{x1,y1},{x2,y2},…}] plots a 3D smooth kernel histogram of the values {xi,yi}.

SmoothHistogram3D[{{x1,y1},{x2,y2},…},espec] plots a 3D smooth kernel histogram with estimator specification espec.

SmoothHistogram3D[{{x1,y1},{x2,y2},…},espec,dfun] plots the distribution function dfun.

SmoothHistogram3D[{data1,data2,…},…] plots smooth kernel histograms for multiple datasets datai.

SmoothKernelDistribution

SmoothKernelDistribution[{x1,x2,…}] represents a smooth kernel distribution based on the data values xi.

SmoothKernelDistribution[{{x1,y1,…},{x2,y2,…},…}] represents a multivariate smooth kernel distribution based on the data values {xi,yi,…}.

SmoothKernelDistribution[…,bw] represents a smooth kernel distribution with bandwidth bw.

SmoothKernelDistribution[…,bw,ker] represents a smooth kernel distribution with bandwidth bw and smoothing kernel ker.

SmoothPointDensity

SmoothPointDensity[pdata] estimates the point density function μ(x) for point data pdata.

SmoothPointDensity[pdata,bw] estimates the density for point data pdata with bandwidth bw.

SmoothPointDensity[pdata,bw,ker] estimates the density for point data pdata with bandwidth bw and smoothing kernel ker.

SmoothPointDensity[bdata,…] estimates the point density function μ(x) for binned data bdata. 

SmoothPointDensity[pproc,…] computes the density function μ(x) for point process pproc.

SnDispersion

SnDispersion[list] gives the Sn statistic of the elements in list.

SnDispersion[list,c] gives the Sn statistic with scaling factor c.

Snippet

Snippet[doc] gives a snippet of text from a document or other content object.

Snippet[doc,n] gives about n lines from the beginning. 

Snippet[doc,-n] gives about n lines from the end.

Snippet[doc,n1;;n2] gives a span from lines n1 to n2

Snippet[doc,n1;;n2;;n3] gives a span from lines n1 to n2 in steps of n3.

Snippet[ContentObject[…],SearchResultObject[…]] gives contextual snippets from a content object based on search results.

SnippetsVideo

SnippetsVideo[video,n] returns a summary video based on n snippets from video.

SnippetsVideo[video,timespec] returns a summary video based on snippets taken at times specified by timespec.

SnubPolyhedron

SnubPolyhedron[poly] gives the snub polyhedron of poly by truncating some corners.

SocialMediaData

SocialMediaData["name"] gives information about the social media entity "name".

SocialMediaData["name","property"] gives the value of the specified property for the social media entity "name".

SocialMediaData[{"name",id},"property"] gives the value of a property for the specified identifier id.

Socket

Socket is a possible value returned by FileType and related functions.

SocketConnect

SocketConnect[address] makes a socket connection to the TCP host at the specified address and returns a SocketObject representing the connection.

SocketConnect[address,"protocol"] makes a connection to the host at address with the specified protocol.

SocketConnect[socket] makes a connection to a local socket opened in the current session.

SocketListen

SocketListen[socket,fun] starts listening on the specified socket, asynchronously applying fun whenever data is received on the socket.

SocketListen[port,fun] starts listening for active connections on the specified port of 127.0.0.1.

SocketListen[address,fun] starts listening for active connections on the specified address address on the local machine.

SocketListen[spec,opts] starts listening for active connections defined by spec using the options opts.

SocketListen[spec] starts listening for active connections defined by spec, but does not set up handler functions, etc.

SocketListener

SocketListener[…] represents a socket listener created by SocketListen.

SocketObject

SocketObject[…] represents a network socket connection.

SocketOpen

SocketOpen[port] opens a socket that accepts TCP connections to localhost:port and returns a SocketObject representing the socket.

SocketOpen[address] opens a socket that accepts TCP connections to the specified local address. 

SocketOpen[address,"protocol"] opens a socket that accepts connections with the specified protocol.

SocketOpen[address,{"protocol","type"}] opens a socket that accepts connections of the specified protocol and type.

SocketReadMessage

SocketReadMessage[socket] reads the next available message on the specified socket, returning it as a byte array.

SocketReadyQ

SocketReadyQ[socket] tests if there is any data immediately available to read from the specified socket. 

SocketReadyQ[socket,t] waits for up to t seconds to see if data becomes available to read.

Sockets

Sockets[] returns all active socket connections initiated by your current Wolfram Language session.

Sockets[All] returns all sockets connected to your current session, including remote sockets originating outside your current session.

Sockets[spec] returns only sockets specified by spec.

SocketWaitAll

SocketWaitAll[{socket1,socket2,…}] waits until there is data ready to read on all of the socketi.

SocketWaitNext

SocketWaitNext[{socket1,socket2,…}] waits until there is data ready to read on any of the socketi, then returns that socket.

SoftmaxLayer

SoftmaxLayer[] represents a softmax net layer.

SoftmaxLayer[n] represents a softmax net layer that uses level n as the normalization dimension.

SokalSneathDissimilarity

SokalSneathDissimilarity[u,v] gives the Sokal–Sneath dissimilarity between Boolean vectors u and v.

SolarEclipse

SolarEclipse[] gives the date of the next solar eclipse.

SolarEclipse[date] gives the date of the next solar eclipse after the specified date.

SolarEclipse[prop] gives the value of property prop for the next solar eclipse.

SolarEclipse[date,prop] gives the value of property prop for the next solar eclipse after date.

SolarTime

SolarTime[] gives the angle on the celestial equator between the Sun and the local antimeridian for the current location and date.

SolarTime[loc] gives the solar time angle for the specified location and current date.

SolarTime[date] gives the solar time angle for the specified date and current location.

SolarTime[loc,date] gives the solar time for the specified location and date.

SolarTime["MeanTime",loc,date] gives the mean solar time for the specified location and date.

SolidAngle

SolidAngle[p,{u1,…,ud}] gives the solid angle at the point p and spanned by the vectors u1,…,ud.

SolidAngle[p,reg] gives the solid angle subtended by the region reg.

SolidBoundaryLoadValue

SolidBoundaryLoadValue[pred,vars,pars] represents a boundary load condition for PDEs with predicate pred indicating where it applies, with model variables vars and global parameters pars.

SolidBoundaryLoadValue[pred,vars,pars,lkeys] represents a boundary load condition with local parameters specified in pars[lkey].

SolidData

SolidData[entity,property] gives the value of the specified property for the solid entity.

SolidData[{entity1,entity2,…},property] gives a list of property values for the specified solid entities.

SolidData[entity,property,annotation] gives the specified annotation associated with the given property.

SolidDisplacementCondition

SolidDisplacementCondition[pred,vars,pars] represents a prescribed displacement on a solid boundary for PDEs with predicate pred indicating where it applies, with model variables vars and global parameters pars.

SolidDisplacementCondition[pred,vars,pars,lkeys] represents a prescribed displacement with local parameters specified in pars[lkey].

SolidFixedCondition

SolidFixedCondition[pred,vars,pars] represents a fully constrained solid boundary for PDEs with predicate pred indicating where it applies, with model variables vars and global parameters pars. 

SolidMechanicsPDEComponent

SolidMechanicsPDEComponent[vars,pars] yields solid mechanics PDE terms with variables vars and parameters pars.

SolidMechanicsStrain

SolidMechanicsStrain[vars,pars,displ] yields a solid mechanics total strain with variables vars, parameters pars and displacements displ.

SolidMechanicsStress

SolidMechanicsStress[vars,pars,strain] yields solid mechanics internal stress with variables vars, parameters pars and total strain strain.

SolidMechanicsStress[vars,pars,strain,displacement] yields solid mechanics stress for nonlinear material laws.

SolidRegionQ

SolidRegionQ[reg] gives True if the 3D region reg is a solid region and False otherwise.

Solve

Solve[expr,vars] attempts to solve the system expr of equations or inequalities for the variables vars. 

Solve[expr,vars,dom] solves over the domain dom. Common choices of dom are Reals, Integers, and Complexes.

SolveAlways

SolveAlways[eqns,vars] gives the values of parameters that make the equations eqns valid for all values of the variables vars. 

SolveDelayed

SolveDelayed is an obsolete option to NDSolve. The option "EquationSimplification" should be used instead.

SolveValues

SolveValues[expr,vars] gives the values of vars determined by the solutions of the system expr.

SolveValues[expr,vars,dom] uses solutions over the domain dom. Common choices of dom are Reals, Integers and Complexes.

Sort

Sort[list] sorts the elements of list into canonical order. 

Sort[list,p] sorts using the ordering function p. 

SortBy

SortBy[list,f] sorts the elements of list in the order defined by applying f to each of them. 

SortBy[list,{f1,f2,…}] breaks ties by successively using the values obtained from the fi.

SortBy[list,f,p] sorts the elements of list using the function p to compare the results of applying f to each element.

SortBy[f] represents an operator form of SortBy that can be applied to an expression.

SortedBy

SortedBy is an option that specifies a function by which to sort the results of a computation.

SortedEntityClass

SortedEntityClass[class,prop] represents an entity class derived from class by sorting according to the values of the property prop. 

SortedEntityClass[class,prop->"order"] sorts according to prop in the order specified.

SortedEntityClass[class,{prop1,prop2,…}] breaks ties by successively using the values of the property specifications propi.

SortedEntityClass[class,sortspec,n] represents the first n entities of class when sorted by sortspec.

SortedEntityClass[class,sortspec,{m,n}] represents the entities m through n of class when sorted by sortspec.

Sound

Sound[primitives] represents a sound. 

Sound[primitives,t] specifies that the sound should have duration t.

Sound[primitives,{tmin,tmax}] specifies that the sound should extend from time tmin to time tmax.

SoundNote

SoundNote[pitch] represents a music-like sound note with the specified pitch.

SoundNote[pitch,t] takes the note to have duration t.

SoundNote[pitch,{tmin,tmax}] takes the note to occupy the time interval tmin to tmax.

SoundNote[pitch,tspec,"style"] takes the note to be in the specified style.

SoundNote[pitch,tspec,"style",opts] uses the specified rendering options for the note.

SoundVolume

SoundVolume is an option to Sound and SoundNote and related functions that specifies the relative volume of the sound produced.

SourcePDETerm

SourcePDETerm[vars,f] represents a source term f with source coefficient f and model variables vars.

SourcePDETerm[vars,f,pars] uses model parameters pars.

Sow

Sow[e] specifies that e should be collected by the nearest enclosing Reap. 

Sow[e,tag] specifies that e should be collected by the nearest enclosing Reap whose pattern matches tag. 

Sow[e,{tag1,tag2,…}] specifies that e should be collected once for each pattern that matches a tagi. 

SpaceCurveData

SpaceCurveData[entity,property] gives the value of the specified property for the space curve entity.

SpaceCurveData[{entity1,entity2,…},property] gives a list of property values for the specified space curve entities.

SpaceCurveData[entity,property,annotation] gives the specified annotation associated with the given property.

SpaceForm

SpaceForm[n] prints as n spaces.

Spacer

Spacer[w] displays as a spacer w printer's points wide.

Spacer[{w,h}] displays as a spacer w points wide and a total of h points high.

Spacer[{w,h,dh}] makes the spacer extend dh points below the baseline. 

Spacings

Spacings is an option to Grid and related constructs that specifies the spacings to leave between successive objects.

Span

i;;j represents a span of elements i through j.

i;; represents a span from i to the end.

;;j represents a span from the beginning to j.

;; represents a span that includes all elements.

i;;j;;k represents a span from i through j in steps of k.

i;;;;k represents a span from i to the end in steps of k.

;;j;;k represents a span from the beginning to j in steps of k.

;;;;k represents a span from the beginning to the end in steps of k. 

SpanAdjustments

SpanAdjustments is an option for selections that specifies the height and width of spanning characters.

SpanCharacterRounding

SpanCharacterRounding is an option for selections that specifies the method used for rounding a spanning character when its size is to be adjusted.

SpanFromAbove

SpanFromAbove is a symbol that can appear at a particular position in a Grid or related construct to indicate that the corresponding position is occupied by a spanning element that appears above it.

SpanFromBoth

SpanFromBoth is a symbol that can appear at a particular position in a Grid or related construct to indicate that the corresponding position is occupied by a spanning element that appears above and to its left.

SpanFromLeft

SpanFromLeft is a symbol that can appear at a particular position in a Grid or related construct to indicate that the corresponding position is occupied by a spanning element that appears to its left.

SpanLineThickness

SpanLineThickness is an option for selections that specifies the thickness in printer's points of line-spanning characters such as ∖[VerticalLine] and ∖[HorizontalLine].

SpanMaxSize

SpanMaxSize is an option for selections that specifies the maximum size of spanning characters such as parentheses and brackets.

SpanMinSize

SpanMinSize is an option for selections that specifies the minimum size of spanning characters such as parentheses and brackets.

SpanSymmetric

SpanSymmetric is an option for selections that specifies whether vertically expandable characters are symmetric about the axis of the selection.

SparseArray

SparseArray[{pos1->v1,pos2->v2,…}] yields a sparse array with all elements zero except for values vi at positions posi.

SparseArray[list] yields a sparse array version of list. 

SparseArray[data,{d1,d2,…}] yields a sparse array representing a d1×d2×… array. 

SparseArray[data,dims,val] yields a sparse array in which unspecified elements are taken to have value val. 

SparseArrayQ

SparseArrayQ[s] yields True if s is a valid SparseArray object and False otherwise.

SpatialBinnedPointData

SpatialBinnedPointData[{reg1->val1,reg2->val2,…}] represents values vali associated with disjoint regions regi. 

SpatialBinnedPointData[{reg1,reg2,…}->{val1,val2,…}] gives the same result. 

SpatialBinnedPointData[…,reg] gives the overall observation region reg. 

SpatialBoundaryCorrection

SpatialBoundaryCorrection is an option to various spatial statistics functions that control how to correct for boundary effects of observation regions. 

SpatialEstimate

SpatialEstimate[{loc1->val1,loc2->val2,…}] creates a spatial prediction from values vali given at locations loci. 

SpatialEstimate[{loc1,loc2,…}->{val1,val2,…}] generates the same result. 

SpatialEstimatorFunction

SpatialEstimatorFunction[] represents a function generated by SpatialEstimate and predicts spatial field values from locations.

SpatialGraphDistribution

SpatialGraphDistribution[n,r] represents a spatial distribution for graphs with n vertices uniformly distributed over the unit square and edges between vertices that are at distance at most r.

SpatialGraphDistribution[n,r,d] represents a spatial distribution for graphs with vertices uniformly distributed over the d-dimensional unit square.

SpatialGraphDistribution[n,r,dist] represents a spatial distribution for graphs with vertices distributed according to the probability distribution dist.

SpatialGraphDistribution[n,r,reg] represents a spatial distribution for graphs with vertices uniformly distributed in the region reg.

SpatialJ

SpatialJ[pdata,r] estimates the J function J(r) for point data pdata at radius r.

SpatialJ[pproc,r] computes J(r) for the point process pproc.

SpatialJ[bdata,r] computes J(r) for binned data bdata. 

SpatialJ[pspec] generates the function J that can be applied repeatedly to different radii r.

SpatialMedian

SpatialMedian[{x1,x2,…}] gives the spatial median of the elements xi.

SpatialMedian[data] gives the spatial median for several different forms of data. 

SpatialNoiseLevel

SpatialNoiseLevel is an option to SpatialEstimate and other spatial functions that gives the noise variance level in the data.

SpatialObservationRegionQ

SpatialObservationRegionQ[reg] tests whether the geometric or geographic region reg can be an observation in spatial statistics. 

SpatialPointData

SpatialPointData[points] represents a collection of spatial locations points.

SpatialPointData[points,reg] represents a collection of points within the region reg.

SpatialPointData[points->vals,…] associates the values vals with the location points.

SpatialPointData[points-><|key1->vals1,…|>,…] associates the key-value annotations keyi->valsi.

SpatialPointData[{p1->data1,p2->data2,…},…] represents the spatial point collection {p1,p2,…} with associated values {data1,data2,…}.

SpatialPointData[{points1,points2,…},…] represents multiple collections of spatial points.

SpatialPointData[{points1->anns1,points2->anns2,…},…] represents multiple collections of spatial points with annotations.

SpatialPointSelect

SpatialPointSelect[spdata,crit] selects a subset of the SpatialPointData spdata according to crit.

SpatialRandomnessTest

SpatialRandomnessTest[pdata] tests whether the point collection pdata is distributed uniformly over the observation region.

SpatialRandomnessTest[pdata,"property"] returns the value of "property".

SpatialTransformationLayer

SpatialTransformationLayer[{h,w}] represents a net layer that applies an affine transformation to an input of size c×h0×w0 and returns an output of size c×h×w.

SpatialTrendFunction

SpatialTrendFunction is an option to SpatialEstimate that specifies what global trend model to use for data. 

Speak

Speak[expr] speaks a spoken representation of the expression expr.

SpeakerMatchQ

SpeakerMatchQ[audio,ref] gives True if speaker features in audio match the one from reference ref and returns False otherwise.

SpeakerMatchQ[{audio1,audio2,…},ref] gives a list of results for each of audioi.

SpeakerMatchQ[ref] represents an operator form of SpeakerMatchQ that can be applied to an audio object.

SpearmanRankTest

SpearmanRankTest[v1,v2] tests whether the vectors v1 and v2 are independent.

SpearmanRankTest[m1,m2] tests whether the matrices m1 and m2 are independent.

SpearmanRankTest[…,"property"] returns the value of "property".

SpeciesData

SpeciesData[name,property] gives the value of the specified property for the species entity.

SpeciesData[{entity1,entity2,…},property] gives a list of property values for the specified species entities.

SpeciesData[entity,property,annotation] gives the specified annotation associated with the given property.

SpecificityGoal

SpecificityGoal is an option for ImageIdentify and related functions that defines what specificity of object to seek to identify.

SpectralLineData

SpectralLineData[entity] gives the values of all known properties for an atomic state or state transition.

SpectralLineData[entity,property] gives the value of the specified property for the given entity.

SpectralLineData[quantity] returns the state transition with the closest wavelength or frequency specified.

SpectralLineData[class,quantity] returns the entity in the specified entity class with the closest wavelength or energy to the specified quantity.

SpectralLineData[spec,{quantity1,quantity2}] returns the entities in spec that fall within the range specified between quantity1 and quantity2.

Spectrogram

Spectrogram[list] plots the spectrogram of list.

Spectrogram[list,n] uses partitions of length n.

Spectrogram[list,n,d] uses partitions with offset d.

Spectrogram[list,n,d,wfun] applies a smoothing window wfun to each partition.

Spectrogram[list,n,d,wfun,m] pads partitions with zeros to length m prior to the computation of the transform.

Spectrogram[audio,…] plots the spectrogram of audio.

Spectrogram[video] plots the spectrogram of the first audio track in video.

SpectrogramArray

SpectrogramArray[list] returns the spectrogram data of list.

SpectrogramArray[list,n] uses partitions of length n.

SpectrogramArray[list,n,d] uses partitions with offset d.

SpectrogramArray[list,n,d,wfun] applies a smoothing window wfun to each partition.

SpectrogramArray[list,n,d,wfun,m] pads partitions with zeros to length m prior to the computation of the transform.

SpectrogramArray[audio,…] returns spectrogram data of audio.

SpectrogramArray[video] returns the spectrogram data of the first audio track in video.

Specularity

Specularity[s] is a graphics directive which specifies that surfaces of 3D graphics objects which follow are to be taken to have specularity s. 

Specularity[s,n] uses specular exponent n. 

SpeechCases

SpeechCases[audio,form] gives a list of cases of text identified as being of type form that appear in the transcription of audio.

SpeechCases[audio,{form1,form2,…}] gives an association of results for all the types formi. 

SpeechCases[audio,formspec->prop] gives the specified property for each result found.

SpeechCases[audio,formspec->{prop1,prop2,…}] gives a list of properties for each result found.

SpeechCases[audio,spec,n] gives the first n cases found.

SpeechInterpreter

SpeechInterpreter[form] represents an interpreter object that can be applied to a speech input to try to interpret it as an object of the specified form. 

SpeechInterpreter[form,test] returns the interpreted object only if applying test to it yields True; otherwise, it returns a Failure object.

SpeechInterpreter[form,test,fail] returns the result of applying the function fail if the test fails.

SpeechRecognize

SpeechRecognize[audio] recognizes speech in audio and returns it as a string.

SpeechRecognize[audio,level] returns a list of strings at the specified structural level.

SpeechRecognize[audio,level,prop] returns prop for text at the given level.

SpeechSynthesize

SpeechSynthesize[expr] synthesizes the contents of expr as an Audio object. 

SpeechSynthesize[expr,voice] uses the specified voice to synthesize the speech signal.

SpellingCorrection

SpellingCorrection is an option for StringMatchQ, Names, and related functions that specifies whether strings should be considered to match even when a small fraction of the characters in them are different. 

SpellingCorrectionList

SpellingCorrectionList["word"] gives a list of possible spelling corrections for "word".

SpellingDictionaries

SpellingDictionaries is a global option that specifies settings for spell checking.

SpellingDictionariesPath

SpellingDictionariesPath is a global option that specifies which directories are searched for spelling dictionaries when the Edit ▶ Check Spelling menu item is used.

Sphere

Sphere[p] represents a unit sphere centered at the point p.

Sphere[p,r] represents a sphere of radius r centered at the point p.

Sphere[{p1,p2,…},r] represents a collection of spheres of radius r.

SpherePoints

SpherePoints[n] gives the positions of n uniformly distributed points on the surface of a unit sphere.

SphericalBesselJ

SphericalBesselJ[n,z] gives the spherical Bessel function of the first kind jn(z). 

SphericalBesselY

SphericalBesselY[n,z] gives the spherical Bessel function of the second kind yn(z). 

SphericalHankelH1

SphericalHankelH1[n,z] gives the spherical Hankel function of the first kind hn(1)(z). 

SphericalHankelH2

SphericalHankelH2[n,z] gives the spherical Hankel function of the second kind hn(2)(z). 

SphericalHarmonicY

SphericalHarmonicY[l,m,θ,ϕ] gives the spherical harmonic Ylm(θ,ϕ). 

SphericalPlot3D

SphericalPlot3D[r,θ,ϕ] generates a 3D plot with a spherical radius r as a function of spherical coordinates θ and ϕ.

SphericalPlot3D[r,{θ,θmin,θmax},{ϕ,ϕmin,ϕmax}] generates a 3D spherical plot over the specified ranges of spherical coordinates.

SphericalPlot3D[{r1,r2,…},{θ,θmin,θmax},{ϕ,ϕmin,ϕmax}] generates a 3D spherical plot with multiple surfaces.

SphericalRegion

SphericalRegion is an option for three-dimensional graphics functions that specifies whether the final image should be scaled so that a sphere drawn around the three‐dimensional bounding box would fit in the display area specified. 

SphericalShell

SphericalShell[c,{rinner,router}] represents a filled spherical shell centered at c with inner radius rinner and outer radius router.

SpheroidalEigenvalue

SpheroidalEigenvalue[n,m,γ] gives the spheroidal eigenvalue with degree n and order m.

SpheroidalJoiningFactor

SpheroidalJoiningFactor[n,m,γ] gives the spheroidal joining factor with degree n and order m.

SpheroidalPS

SpheroidalPS[n,m,γ,z] gives the angular spheroidal function PSn,m(γ,z) of the first kind.

SpheroidalPSPrime

SpheroidalPSPrime[n,m,γ,z] gives the derivative with respect to z of the angular spheroidal function PSn,m(γ,z) of the first kind.

SpheroidalQS

SpheroidalQS[n,m,γ,z] gives the angular spheroidal function QSn,m(γ,z) of the second kind.

SpheroidalQSPrime

SpheroidalQSPrime[n,m,γ,z] gives the derivative with respect to z of the angular spheroidal function QSn,m(γ,z) of the second kind.

SpheroidalRadialFactor

SpheroidalRadialFactor[n,m,c] gives the spheroidal radial factor with degree n and order m.

SpheroidalS1

SpheroidalS1[n,m,γ,z] gives the radial spheroidal function Sn,m(1)(γ,z) of the first kind.

SpheroidalS2

SpheroidalS2[n,m,γ,z] gives the radial spheroidal function Sn,m(2)(γ,z) of the second kind.

Splice

Splice[{e1,e2,…}] represents an expression that will automatically be spliced into any list in which it appears as the sequence of elements ei. 

Splice[{e1,e2,…},hpatt] represents an expression that will automatically be spliced into any expression whose head matches the pattern hpatt.

SplicedDistribution

SplicedDistribution[{w1,w2,…,wn},{c0,c1,…,cn},{dist1,dist2,…,distn}] represents the distribution obtained by splicing the distributions dist1, dist2, … truncated on the intervals {c0,c1}, {c1,c2}, … with weights w1, w2, … .

SplineClosed

SplineClosed is an option for B-spline functions and graphics primitives that specifies whether spline curves or surfaces should be closed. 

SplineDegree

SplineDegree is an option for spline functions and graphics primitives that specifies the degree of polynomial basis to use.

SplineKnots

SplineKnots is an option for B-spline functions and graphics primitives that specifies the positions of knots.

SplineWeights

SplineWeights is an option for B-spline functions and graphics primitives that specifies weights of control points.

Split

Split[list] splits list into sublists consisting of runs of identical elements. 

Split[list,test] treats pairs of adjacent elements as identical whenever applying the function test to them yields True. 

SplitBy

SplitBy[list,f] splits list into sublists consisting of runs of successive elements that give the same value when f is applied.

SplitBy[list,{f1,f2,…}] recursively splits list into sublists by testing elements successively with each of the fi.

SpokenString

SpokenString[expr] gives a string of text corresponding to a spoken representation of the expression expr.

SpotLight

SpotLight[col,pt,α] is a three-dimensional graphics directive to use in coloring 3D surfaces that specifies the spotlight of color col at position pt aimed at the center with half-angle α.

SpotLight[col,{pt1,pt2},α] uses the spotlight at position pt1 aimed at pt2 with half-angle α.

SpotLight[col,{pt,tar},{α,s},att] uses the spotlight with spot exponent s and attenuation att.

Sqrt

Sqrt[z] or @z gives the square root of z. 

Square

Square[x] displays as x.

SquaredEuclideanDistance

SquaredEuclideanDistance[u,v] gives the squared Euclidean distance between vectors u and v.

SquareFreeQ

SquareFreeQ[expr] gives True if expr is a square-free polynomial or number, and False otherwise.

SquareFreeQ[expr,vars] gives True if expr is square free with respect to the variables vars. 

SquareIntersection

SquareIntersection[x,y,…] displays as x⊓y⊓….

SquareMatrixQ

SquareMatrixQ[m] gives True if m is a square matrix, and False otherwise.

SquareRepeatingElement

SquareRepeatingElement[spec] represents a square array of elements of type spec in an interpreter, API or form specification.

SquareRepeatingElement[spec,max] represents a square array of elements of maximum size max×max.

SquareRepeatingElement[spec,{min,max}] represents a square array of elements of size between min and max.

SquaresR

SquaresR[d,n] gives the number of ways rd(n) to represent the integer n as a sum of d squares.

SquareSubset

SquareSubset[x,y,…] displays as x⊏y⊏….

SquareSubsetEqual

SquareSubsetEqual[x,y,…] displays as x⊑y⊑….

SquareSuperset

SquareSuperset[x,y,…] displays as x⊐y⊐….

SquareSupersetEqual

SquareSupersetEqual[x,y,…] displays as x⊒y⊒….

SquareUnion

SquareUnion[x,y,…] displays as x⊔y⊔….

SquareWave

SquareWave[x] gives a square wave that alternates between +1 and -1 with unit period.

SquareWave[{y1,y2},x] gives a square wave that alternates between y1 and y2 with unit period. 

SSSTriangle

SSSTriangle[a,b,c] returns a filled triangle with sides of lengths a, b, and c.

StabilityMargins

StabilityMargins is an option to frequency response plots such as BodePlot, NyquistPlot, and NicholsPlot that specifies the gain and phase margins to be shown on the plot.

StabilityMarginsStyle

StabilityMarginsStyle is an option to frequency response plots such as BodePlot, NyquistPlot, and NicholsPlot that specifies the styles in which the gain and phase margins are to be drawn.

StableDistribution

StableDistribution[type,α,β,μ,σ] represents the stable distribution Stype with index of stability α, skewness parameter β, location parameter μ, and scale parameter σ.

Stack

Stack[] shows the current evaluation stack, giving a list of the tags associated with evaluations that are currently being done. 

Stack[pattern] gives a list of expressions currently being evaluated which match the pattern. 

StackBegin

StackBegin[expr] evaluates expr, starting a fresh evaluation stack. 

StackComplete

StackComplete[expr] evaluates expr with intermediate expressions in evaluation chains included on the stack. 

StackedDateListPlot

StackedDateListPlot[{{date1,y1},{date2,y2},…}] plots points with values yi at a sequence of dates.

StackedDateListPlot[{y1,y2,…},datespec] plots points with dates at equal intervals specified by datespec.

StackedDateListPlot[tseries] plots the time series tseries.

StackedDateListPlot[{data1,data2,…}] plots data from all the datai.

StackedDateListPlot[{…,w[datai],…}] plots datai with features defined by the symbolic wrapper w.

StackedListPlot

StackedListPlot[{data1,data2,…}] plots lines for each of the datai, with the ith curve being the accumulation of values in data1 through datai.

StackedListPlot[{…,w[datai],…}] plots datai with features defined by the symbolic wrapper w.

StackInhibit

StackInhibit[expr] evaluates expr without modifying the evaluation stack. 

StadiumShape

StadiumShape[{{x1,y1},{x2,y2}},r] represents a stadium of radius r between the points {x1,y1} and {x2,y2}.

StandardAtmosphereData

StandardAtmosphereData[altitude,property] returns the value of the property at the specified geometrical altitude for the chosen model of the standard Earth atmosphere.

StandardAtmosphereData[layer,property] returns a piecewise symbolic approximation with the range of an atmospheric layer for the property.

StandardAtmosphereData["SymbolicApproximation",property] returns the full piecewise symbolic approximation for the property.

StandardDeviation

StandardDeviation[data] gives the standard deviation estimate of the elements in data. 

StandardDeviation[dist] gives the standard deviation of the distribution dist.

StandardForm

StandardForm[expr] prints as the standard Wolfram Language two-dimensional representation of expr. 

Standardize

Standardize[list] shifts and rescales the elements of list to have zero mean and unit sample variance.

Standardize[list,f1] shifts the elements in list by f1[list] and rescales them to have unit sample variance.

Standardize[list,f1,f2] shifts by f1[list] and scales by f2[list].

Standardized

Standardized is an option that determines whether to standardize the data.

StandardOceanData

StandardOceanData[spec] returns the thermodynamic properties of seawater for the specified parameters.

StandardOceanData[spec,property] returns the specified property for the given parameters. 

Star

Star[x,y,…] displays as x⋆y⋆….

StarClusterData

StarClusterData[entity,property] gives the value of the specified property for the star cluster entity.

StarClusterData[{entity1,entity2,…},property] gives a list of property values for the specified star cluster entities.

StarClusterData[entity,property,annotation] gives the specified annotation associated with the given property.

StarData

StarData[entity,property] gives the value of the specified property for the star entity.

StarData[{entity1,entity2,…},property] gives a list of property values for the specified star entities.

StarData[entity,property,annotation] gives the specified annotation associated with the property.

StarGraph

StarGraph[n] gives the star graph with n vertices Sn.

StartAsynchronousTask

StartAsynchronousTask[task] allows asynchronous evaluations from task after it has been stopped.

StartExternalSession

StartExternalSession["sys"] starts an external session using the external evaluator sys, returning an external session object.

StartExternalSession[assoc] starts the external evaluator specified by assoc.

StartExternalSession[{"sys",opts}] uses the options opts for the external evaluator.

StartExternalSession[sys->type] specifies that output from the external evaluator should be converted to the specified type.

StartExternalSession[DatabaseReference[ref]] uses the database specified by ref to start a database session.

StartingStepSize

StartingStepSize is an option to NDSolve and related functions that specifies the initial step size to use in trying to generate results.

StartOfLine

StartOfLine represents the start of a line in a string for purposes of matching in StringExpression.

StartOfString

StartOfString represents the start of a string for purposes of matching in StringExpression.

StartProcess

StartProcess["executable"] executes an external program, yielding a ProcessObject to represent the resulting subprocess.

StartProcess[{"executable", arg 1, arg 2, ...}] executes an external program, passing it the specified arguments arg i.

StartWebSession

StartWebSession[] starts a web session and returns a web session object.

StartWebSession["browser"] starts a web session using the specified browser.

StateDimensions

StateDimensions is an option to TemporalData that specifies the dimensions of the state space. 

StateFeedbackGains

StateFeedbackGains[sspec,{p1,…,pn}] gives the state feedback gains for the system specification sspec to place its closed-loop poles at pi.

StateFeedbackGains[…,"prop"] gives the value of the property "prop".

StateOutputEstimator

StateOutputEstimator[ssm,l] constructs an estimator for the StateSpaceModel ssm, with estimator gain matrix l.

StateOutputEstimator[{ssm,sensors},l] uses only sensors as the measurements of ssm.

StateOutputEstimator[{ssm,sensors,dinputs},l] specifies dinputs as the deterministic inputs of ssm.

StateResponse

StateResponse[sys,u,{t,tmin,tmax}] gives the numeric state response of the state-space model sys to input u for tmin≤t≤tmax. 

StateResponse[sys,{u[0],u[1],…}] gives the response of the discrete-time state-space model sys to the input sequence u[i].

StateResponse[sys,u,t] gives the symbolic state response as a function of time t.

StateResponse[sys,{u1,…,um},…] gives the state response for multiple inputs ui. 

StateResponse[{sys,{x10,x20,…,xn0}},…, …] gives the response with initial states xi0.

StateSpaceModel

StateSpaceModel[{a,b,c,d}] represents the standard state-space model with state matrix a, input matrix b, output matrix c, and transmission matrix d.

StateSpaceModel[{a,b,c,d,e}] represents a descriptor state-space model with descriptor matrix e.

StateSpaceModel[sys] gives a state-space model corresponding to the systems model sys.

StateSpaceModel[eqns,{{x1,x10},…},{{u1,u10},…},{g1,…},τ] gives the state-space model obtained by Taylor linearization about the point (xi0,ui0) of the differential or difference equations eqns with outputs gi and independent variable τ.

StateSpaceRealization

StateSpaceRealization is an option to StateSpaceModel that specifies its canonical representation.

StateSpaceTransform

StateSpaceTransform[sys,{p,q}] transforms the state-space model sys using the matrices p and q. 

StateSpaceTransform[sys,{{x1->p1[z],…},{z1->q1[x],…}}] transforms using the variable transformations {x1->p1[z],…} and {z1->q1[x],…}.

StateTransformationLinearize

StateTransformationLinearize[asys] linearizes the AffineStateSpaceModel asys by state transformation.

StateTransformationLinearize[asys,{z,lform}] specifies the new states z and form of linearization lform. 

StateTransformationLinearize[asys,…,"prop"] computes the property "prop".

StationaryDistribution

StationaryDistribution[proc] represents the stationary distribution of the process proc, when it exists. 

StationaryWaveletPacketTransform

StationaryWaveletPacketTransform[data] gives the stationary wavelet packet transform (SWPT) of an array of data.

StationaryWaveletPacketTransform[data,wave] gives the stationary wavelet packet transform using the wavelet wave.

StationaryWaveletPacketTransform[data,wave,r] gives the stationary wavelet packet transform using r levels of refinement.

StationaryWaveletTransform

StationaryWaveletTransform[data] gives the stationary wavelet transform (SWT) of an array of data.

StationaryWaveletTransform[data,wave] gives the stationary wavelet transform using the wavelet wave.

StationaryWaveletTransform[data,wave,r] gives the stationary wavelet transform using r levels of refinement.

StatusCentrality

StatusCentrality[g] gives a list of status centralities for the vertices in the graph g.

StatusCentrality[{v->w,…}] uses rules v->w to specify the graph g.

StepMonitor

StepMonitor is an option for iterative numerical computation functions that gives an expression to evaluate whenever a step is taken by the numerical method used. 

StereochemistryElements

StereochemistryElements is an option for Molecule that specifies the local stereochemical arrangement of atoms in a molecule.

StieltjesGamma

StieltjesGamma[n] gives the Stieltjes constant γn. 

StieltjesGamma[n,a] gives the generalized Stieltjes constant γn(a).

StippleShading

StippleShading[] is a three-dimensional graphics directive specifying that objects that follow are to be drawn using small dots.

StippleShading[d] uses the density d of shading.

StippleShading[col] uses dots with the specified color col.

StippleShading[d,col] uses dots of color col with the density d of shading.

StirlingS1

StirlingS1[n,m] gives the Stirling number of the first kind Sn(m). 

StirlingS2

StirlingS2[n,m] gives the Stirling number of the second kind n(m). 

StopAsynchronousTask

StopAsynchronousTask[task] stops asynchronous evaluations from task.

StoppingPowerData

StoppingPowerData[entity,{"Particle"->particle,"Energy"->quantity},property] gives the value of the specific property for the substance for the specified particle and the energy of that particle.

StrataVariables

StrataVariables is an option for fitting functions such as CoxModelFit that specify the variables on which the model should be stratified. 

StratonovichProcess

StratonovichProcess[{a,b},x,t] represents a Stratonovich process x(t), where x(t)a(t,x(t))t+b(t,x(t))◦ w(t) .

StratonovichProcess[{a,b,c},x,t] represents a Stratonovich process y(t)c(t,x(t)), where x(t)a(t,x(t))t+b(t,x(t))◦ w(t) .

StratonovichProcess[…,…,{x,x0},{t,t0}] represents a Stratonovich process with initial condition x(t0)x0.

StratonovichProcess[…,…,…,Σ] uses a Wiener process w(t), with covariance Σ.

StratonovichProcess[proc] converts proc to a standard Stratonovich process whenever possible.

StratonovichProcess[sdeqns,expr,x,t,wdproc] represents a Stratonovich process specified by a stochastic differential equation sdeqns, output expression expr, with state x and time t, driven by w following the process dproc. 

StreamColorFunction

StreamColorFunction is an option for StreamPlot and related functions that specifies a function to apply to determine colors along streamlines. 

StreamColorFunctionScaling

StreamColorFunctionScaling is an option for graphics functions that specifies whether arguments supplied to a stream color function should be scaled to lie between 0 and 1. 

StreamDensityPlot

StreamDensityPlot[{{vx,vy},r},{x,xmin,xmax},{y,ymin,ymax}] generates a stream plot of the vector field {vx,vy} as a function of x and y, superimposed on a background density plot of the scalar field r. 

StreamDensityPlot[{vx,vy},{x,xmin,xmax},{y,ymin,ymax}] takes the scalar field to be the norm of the vector field.

StreamDensityPlot[{{vx,vy},{wx,wy},…,r},{x,xmin,xmax},{y,ymin,ymax}] generates plots of several vector fields. 

StreamDensityPlot[…,{x,y}∈reg] takes the variables {x,y} to be in the geometric region reg. 

StreamMarkers

StreamMarkers is an option for StreamPlot, ListStreamPlot and related functions that specifies what markers to draw at the field points plotted.

StreamPlot

StreamPlot[{vx,vy},{x,xmin,xmax},{y,ymin,ymax}] generates a stream plot of the vector field {vx,vy} as a function of x and y. 

StreamPlot[{{vx,vy},{wx,wy},…},{x,xmin,xmax},{y,ymin,ymax}] generates plots of several vector fields. 

StreamPlot[…,{x,y}∈reg] takes the variables {x,y} to be in the geometric region reg. 

StreamPlot3D

StreamPlot3D[{vx,vy,vz},{x,xmin,xmax},{y,ymin,ymax},{z,zmin,zmax}] plots streamlines for the vector field {vx,vy,vz} as functions of x, y and z.

StreamPlot3D[{vx,vy,vz},{x,y,z}∈reg] takes the variables {x,y,z} to be in the geometric region reg. 

StreamPoints

StreamPoints is an option to StreamPlot, ListStreamPlot, and related functions that determines how many streamlines to draw.

StreamPosition

StreamPosition[stream] returns an integer that specifies the position of the current point in an open stream. 

Streams

Streams[] gives a list of all streams that are currently open. 

Streams["name"] lists only streams with the specified name. 

StreamScale

StreamScale is an option to StreamPlot, ListStreamPlot, and related functions that determines the length and arrowhead size of streamlines that are drawn. 

StreamStyle

StreamStyle is an option to StreamPlot, StreamDensityPlot, and related functions that determines the style to use for drawing streamlines.

StrictInequalities

StrictInequalities is an option to FunctionSign and FunctionMonotonicity, etc. that determines whether strict inequalities should be used in definitions. 

String

String is the head of a character string "text". 

StringByteCount

StringByteCount["string"] gives the total number of bytes used to store the characters in a string.

StringCases

StringCases["string",patt] gives a list of the substrings in "string" that match the string expression patt. 

StringCases["string",lhs->rhs] gives a list of the values of rhs corresponding to the substrings that match the string expression lhs. 

StringCases["string",p,n] includes only the first n substrings that match. 

StringCases["string",{p1,p2,…}] gives substrings that match any of the pi. 

StringCases[{s1,s2,…},p] gives the list of results for each of the si. 

StringCases[patt] represents an operator form of StringCases that can be applied to an expression.

StringContainsQ

StringContainsQ["string",patt] yields True if any substring in "string" matches the string expression patt, and yields False otherwise.

StringContainsQ["string",{patt1,patt2,…}] yields True if any substring matches any of the patti.

StringContainsQ[{string1,string2,…},patt] gives a list of the results for each of the "stringi".

StringContainsQ[patt] represents an operator form of StringContainsQ that can be applied to an expression.

StringCount

StringCount["string","sub"] gives a count of the number of times "sub" appears as a substring of "string". 

StringCount["string",patt] gives the number of substrings in "string" that match the general string expression patt. 

StringCount["string",{patt1,patt2,…}] counts the number of occurrences of any of the patti. 

StringCount[{s1,s2,…},p] gives the list of results for each of the si.

StringDelete

StringDelete["string",patt] yields the string obtained by deleting from string all occurrences of anything matching the string pattern patt.

StringDelete[patt] represents an operator form of StringDelete that can be applied to an expression.

StringEndsQ

StringEndsQ["string",patt] yields True if the end of "string" matches the string expression patt, and yields False otherwise.

StringEndsQ["string",{patt1,patt2,…}] yields True if the end of "string" matches any of the patti.

StringEndsQ[{string1,string2,…},patt] gives a list of the results for each of the "stringi".

StringEndsQ[patt] represents an operator form of StringEndsQ that can be applied to an expression.

StringExpression

s1~~s2~~… or StringExpression[s1,s2,…] represents a sequence of strings and symbolic string objects si. 

StringExtract

StringExtract["string",n] extracts the nth block of characters in string, where blocks of characters are defined as delimited by whitespace.

StringExtract["string",{pos1,pos2,…}] extracts blocks at several positions in string.

StringExtract["string",sep->pos] takes blocks to be delimited by separators that match sep.

StringExtract["string",pos1,pos2,…] extracts blocks at positions posi, delimiting with whitespace for the lowest level, newlines for the next level, and a successively increasing number of newlines thereafter.

StringExtract["string",sep1->pos1,sep2->pos2,…] gives a nested list of blocks, with the sepi used as separators for successive levels.

StringForm

StringForm["controlstring",expr1,…] prints as the text of the controlstring, with the printed forms of the expri embedded. 

StringFormat

StringFormat["string"] attempts to determine what ImportString format could be used to import the string "string".

StringFormatQ

StringFormatQ["string","fmt"] gives True if the string "string" might be imported as format "fmt" and gives False otherwise.

StringFormatQ["string",{fmt1,fmt2,…}] gives True if "string" might be imported as one of "fmti".

StringFreeQ

StringFreeQ["string",patt] yields True if no substring in "string" matches the string expression patt, and yields False otherwise.

StringFreeQ["string",{patt1,patt2,…}] yields True if no substring matches any of the patti.

StringFreeQ[{string1,string2,…},patt] gives a list of the results for each of the "stringi".

StringFreeQ[patt] represents an operator form of StringFreeQ that can be applied to an expression.

StringInsert

StringInsert["string","snew",n] yields a string with "snew" inserted starting at position n in "string". 

StringInsert["string","snew",-n] inserts at position n from the end of "string". 

StringInsert["string","snew",{n1,n2,…}] inserts a copy of "snew" at each of the positions ni. 

StringInsert[{s1,s2,…},"snew",n] gives the list of results for each of the si.

StringJoin

"s1"<>"s2"<>…, StringJoin["s1","s2",…], or StringJoin[{"s1","s2",…}] yields a string consisting of a concatenation of the si. 

StringLength

StringLength["string"] gives the number of characters in a string. 

StringMatchQ

StringMatchQ["string",patt] tests whether "string" matches the string pattern patt. 

StringMatchQ["string",RegularExpression["regex"]] tests whether "string" matches the specified regular expression. 

StringMatchQ["string",{patt1,patt2,…}] test whether "string" matches any of the patti.

StringMatchQ[{string1,string2,…},patt] gives the list of the results for each of the "stringi". 

StringMatchQ[patt] represents an operator form of StringMatchQ that can be applied to an expression.

StringPadLeft

StringPadLeft["string",n] makes string be of length n, padding it on the left with spaces or truncating it if necessary. 

StringPadLeft["string",n,"padding"] pads by repeating copies of the string padding.

StringPadLeft[{s1,s2,…}] pads strings with spaces on the left to make them all the same length.

StringPadLeft[{s1,s2,…},n,…] pads or truncates to make all strings of length n.

StringPadRight

StringPadRight["string",n] makes string be of length n, padding it on the right with spaces or truncating it if necessary. 

StringPadRight["string",n,"padding"] pads by repeating copies of the string padding.

StringPadRight[{s1,s2,…}] pads strings with spaces on the right to make them all the same length.

StringPadRight[{s1,s2,…},n,…] pads or truncates to make all strings of length n.

StringPart

StringPart["string",n] gives the nth character in "string".

StringPart["string",{n1,n2,…}] gives a list of the nith characters in "string".

StringPart["string",m;;n;;s] gives a list of the characters in "string" from the mth through the nth in steps of s.

StringPart[{s1,s2,…},spec] gives the list of results for each of the si.

StringPartition

StringPartition["string",n] partitions string into nonoverlapping substrings of length n.

StringPartition["string",n,d] generates substrings with offset d.

StringPosition

StringPosition["string","sub"] gives a list of the starting and ending character positions at which "sub" appears as a substring of "string". 

StringPosition["string",patt] gives all positions at which substrings matching the general string expression patt appear in "string". 

StringPosition["string",patt,n] includes only the first n occurrences of patt. 

StringPosition["string",{patt1,patt2,…}] gives positions of all the patti. 

StringPosition[{s1,s2,…},p] gives the list of results for each of the si. 

StringPosition[patt] represents an operator form of StringPosition that can be applied to an expression.

StringQ

StringQ[expr] gives True if expr is a string, and False otherwise.

StringRepeat

StringRepeat["str",n] creates a string consisting of "str" repeated n times.

StringRepeat["str",n,max] creates a string consisting of up to n copies of "str", truncated to be of maximum total length at most max.

StringReplace

StringReplace["string",s->sp] replaces the string expression s by sp wherever it appears in "string". 

StringReplace["string",{s1->sp1,s2->sp2,…}] replaces the string expressions si by spi whenever they appear as substrings of "string".

StringReplace["string",srules,n] does only the first n replacements. 

StringReplace[{s1,s2,…},srules] gives the list of results for each of the si. 

StringReplace[srules] represents an operator form of StringReplace that can be applied to an expression.

StringReplaceList

StringReplaceList["string",s->sp] or StringReplaceList["string",{s1->sp1,s2->sp2,…}] gives a list of the strings obtained by replacing each individual occurrence of substrings in "string" matching the string expressions si. 

StringReplaceList["string",srules,n] gives a list of the first n results obtained. 

StringReplaceList[{s1,s2,…},srules] gives the list of results for each of the si. 

StringReplacePart

StringReplacePart["string","snew",{m,n}] replaces the characters at positions m through n in "string" by "snew". 

StringReplacePart["string","snew",{{m1,n1},{m2,n2},…}] inserts copies of "snew" at several positions. 

StringReplacePart["string",{"snew1","snew2",…},{{m1,n1},{m2,n2},…}] replaces characters at positions mi through ni in "string" by "snewi". 

StringReplacePart["snew",{m,n}] represents an operator form of StringReplacePart that can be applied to an expression.

StringReverse

StringReverse["string"] reverses the order of the characters in "string".

StringRiffle

StringRiffle[{s1,s2,s3,…}] creates a string by concatenating all the si, with spaces inserted between them.

StringRiffle[{{s11,s12,…},{s21,s22,…},…}] creates a string by concatenating the sij, and inserting spaces at the lowest level and newlines at the higher level.

StringRiffle[list,sep] inserts the separator sep between all elements in list.

StringRiffle[list,{"left","sep","right"}] use left and right as delimiters after concatenation.

StringRiffle[list,sep1,sep2,…] inserts separator sepi between elements of list at level i.

StringRotateLeft

StringRotateLeft[string,n] cycles the characters in string n positions to the left.

StringRotateLeft[string] cycles one position to the left.

StringRotateRight

StringRotateRight[string,n] cycles the characters in string n positions to the right.

StringRotateRight[string] cycles one position to the right.

StringSkeleton

StringSkeleton[n] represents a sequence of n omitted characters in a string printed with Short. The standard print form for StringSkeleton is an ellipsis. 

StringSplit

StringSplit["string"] splits "string" into a list of substrings separated by whitespace. 

StringSplit["string",patt] splits into substrings separated by delimiters matching the string expression patt. 

StringSplit["string",{p1,p2,…}] splits at any of the pi. 

StringSplit["string",patt->val] inserts val at the position of each delimiter. 

StringSplit["string",{p1->v1,…}] inserts vi at the position of each delimiter pi. 

StringSplit["string",patt,n] splits into at most n substrings. 

StringSplit[{s1,s2,…},p] gives the list of results for each of the si.

StringStartsQ

StringStartsQ["string",patt] yields True if the beginning of "string" matches the string expression patt, and yields False otherwise.

StringStartsQ["string",{patt1,patt2,…}] yields True if the beginning of "string" matches any of the patti.

StringStartsQ[{string1,string2,…},patt] gives a list of the results for each of the "stringi".

StringStartsQ[patt] represents an operator form of StringStartsQ that can be applied to an expression.

StringTakeDrop

StringTakeDrop["string",n] gives a pair of strings containing the first n characters in "string" and the remaining characters.

StringTakeDrop["string",seq] gives the pair {StringTake["string",seq],StringDrop["string",seq]}.

StringTemplate

StringTemplate["string"] yields a TemplateObject expression that represents a string template to be applied to arguments. 

StringTemplate[src] uses File[…], URL[…] or CloudObject[…] as the source for the string template.

StringTemplate[form,args] yields a TemplateObject with arguments, suitable for cloud deployment or other evaluation.

StringToByteArray

StringToByteArray["string"] returns a byte array corresponding to the UTF-8 encoding of the specified string.

StringToByteArray["string","encoding"] uses the specified character encoding.

StringToStream

StringToStream["string"] opens an input stream for reading from a string. 

StringTrim

StringTrim["string"] trims whitespace from the beginning and end of "string".

StringTrim["string",patt] trims substrings matching patt from the beginning and end.

StructuralImportance

StructuralImportance[rdist] gives the structural importances for all components in the ReliabilityDistribution rdist.

StructuralImportance[fdist] gives the structural importances for all components in the FailureDistribution fdist.

StructuralImportance[bexpr,{x1,x2,…}] gives the structural importance for the components x1, x2, … in the Boolean expression bexpr.

StructuredArray

StructuredArray[st,{d1,d2,…},data] represents a d1×d2×… array with structure type st and specific content data. 

StructuredSelection

StructuredSelection is an option for Cell that specifies whether to allow only complete subexpressions in the cell to be selected interactively using the front end.

StruveH

StruveH[n,z] gives the Struve function Hn(z). 

StruveL

StruveL[n,z] gives the modified Struve function Ln(z). 

Stub

Stub is an attribute which specifies that if a symbol is ever used, Needs should automatically be called on the context of the symbol. 

StudentTDistribution

StudentTDistribution[ν] represents a standard Student t distribution with ν degrees of freedom.

StudentTDistribution[μ,σ,ν] represents a Student t distribution with location parameter μ, scale parameter σ, and ν degrees of freedom.

Style

Style[expr,options] displays with expr formatted using the specified option settings. 

Style[expr,"style"] uses the option settings for the specified style in the current notebook. 

Style[expr,color] displays using the specified color. 

Style[expr,Bold] displays with fonts made bold. 

Style[expr,Italic] displays with fonts made italic. 

Style[expr,Underlined] displays with fonts underlined. 

Style[expr,Larger] displays with fonts made larger. 

Style[expr,Smaller] displays with fonts made smaller. 

Style[expr,n] displays with font size n. 

Style[expr,Tiny], Style[expr,Small], etc. display with fonts that are tiny, small, etc. 

Subdivide

Subdivide[n] generates the list {0,1/n,2/n,…,1}.

Subdivide[xmax,n] generates the list of values obtained by subdividing the interval 0 to xmax into n equal parts.

Subdivide[xmin,xmax,n] generates the list of values from subdividing the interval xmin to xmax.

Subfactorial

Subfactorial[n] gives the number of permutations of n objects that leave no object fixed.

Subgraph

Subgraph[g,{v1,v2,…}] gives the subgraph of the graph g generated by the vertices vi.

Subgraph[g,{e1,e2,…}] gives the subgraph generated by the edges ej.

Subgraph[g,patt] gives the subgraph generated by the vertices and edges that match the pattern patt.

Subgraph[{v->w,…},…] uses rules v->w to specify the graph g. 

SubMinus

SubMinus[expr] displays as expr-.

SubPlus

SubPlus[expr] displays as expr+.

SubresultantPolynomialRemainders

SubresultantPolynomialRemainders[poly1,poly2,var] gives the subresultant polynomial remainder sequence of the polynomials poly1 and poly2 with respect to the variable var.

SubresultantPolynomialRemainders[poly1,poly2,var,Modulus->p] computes the subresultant polynomial remainder sequence modulo the prime p.

SubresultantPolynomials

SubresultantPolynomials[poly1,poly2,var] generates a list of subresultant polynomials of the polynomials poly1 and poly2 with respect to the variable var.

SubresultantPolynomials[poly1,poly2,var,Modulus->p] computes the subresultant polynomials modulo the prime p.

Subresultants

Subresultants[poly1,poly2,var] generates a list of the principal subresultant coefficients of the polynomials poly1 and poly2 with respect to the variable var.

Subresultants[poly1,poly2,var,Modulus->p] computes the principal subresultant coefficients modulo the prime p. 

Subscript

Subscript[x,y] is an object that formats as xy. 

Subscript[x,y1,y2,…] formats as xy1,y2,….

Subset

Subset[x,y,…] displays as x⊂y⊂….

SubsetCases

SubsetCases[list,patt] gives a list of the sublists in list that match the pattern patt in any order.

SubsetCases[list,patt->rhs] gives a list of the values of rhs corresponding to matching sublists.

SubsetCases[list,patt,n] includes only the first n matches.

SubsetCount

SubsetCount[list,sub] gives a count of the number of times sub appears in any order as a sublist of list.

SubsetCount[list,patt] gives the number of sublists in list that match the general pattern patt in any order.

SubsetEqual

SubsetEqual[x,y,…] displays as x⊆y⊆….

SubsetMap

SubsetMap[f,{e1,e2,…},{i,j,…}] yields an expression in which the elements ei, ej, … in the list {e1,e2,…} are replaced with the corresponding elements of the list obtained by evaluating f[{ei,ej,…}].

SubsetMap[f,expr,{pos1,pos2,…}] replaces elements of expr at positions pos1, pos2, ….

SubsetMap[f,{pos1,pos2,…}] represents an operator form of SubsetMap that can be applied to an expression.

SubsetPosition

SubsetPosition[list,sublist] gives a list of positions at which sublist appears in list in any order.

SubsetPosition[list,patt] gives all positions at which sublists matching patt in any order appear in list.

SubsetPosition[list,patt,n] includes only the first n positions.

SubsetQ

SubsetQ[list1,list2] yields True if list2 is a subset of list1, and False otherwise.

SubsetReplace

SubsetReplace[list,rules] replaces sublists in list according to the specified rule or list of rules.

SubsetReplace[list,rules,n] does only the first n replacements.

SubsetReplace[rules] represents an operator form of SubsetReplace that can be applied to an expression.

SubStar

SubStar[expr] displays as expr*.

Subsuperscript

Subsuperscript[x,y,z] is an object that formats as xyz. 

SubtitleEncoding

SubtitleEncoding is an option for Export and other functions that specifies the subtitle encoding to use when creating a video file.

SubtitleTrackSelection

SubtitleTrackSelection is an option that specifies the subtitle tracks of interest.

Subtract

x-y is equivalent to x+(-1*y). 

SubtractFrom

x-=dx subtracts dx from x and returns the new value of x. 

SubtractSides

SubtractSides[rel,x] subtracts x from each side of the equation or inequality rel.

SubtractSides[rel1,rel2] subtracts the corresponding sides of two equations or inequalities.

SubtractSides[rel] subtracts the right-hand side of rel from each side, producing a zero right-hand side.

SubValues

SubValues[f] gives a list of transformation rules corresponding to all subvalues (values for f[…][…]…) defined for the symbol f.

SubValues["symbol"] gives a list of transformation rules corresponding to all subvalues defined for the symbol named "symbol" if it exists.

Succeeds

Succeeds[x,y,…] displays as x≻y≻….

SucceedsEqual

SucceedsEqual[x,y,…] displays as x⪰y⪰….

SucceedsSlantEqual

SucceedsSlantEqual[x,y,…] displays as x≽y≽….

SucceedsTilde

SucceedsTilde[x,y,…] displays as x≿y≿….

Success

Success["tag",assoc] represents a success of a type indicated by tag, with details given by the association assoc.

SuchThat

SuchThat[x,y] displays as x∍y.

SumConvergence

SumConvergence[f,n] gives conditions for the sum ∑+n%∞f to be convergent.

SumConvergence[f,{n1,n2,…}] gives conditions for the multiple sum ∑+n1%∞∑+n2%∞… f to be convergent.

SumConvergence[f,{n,a,∞}] gives conditions for the sum ∑+n=a%∞f to be convergent on the interval [a,∞).

SumConvergence[f,{n,a,∞},…,{m,b,∞}] gives conditions for the multiple sum ∑+n=a%∞…∑+m=b%∞f to be convergent.

SummationLayer

SummationLayer[] represents a net layer that sums all of its input elements.

Sunday

Sunday is a day of the week.

SunPosition

SunPosition[] gives the position of the Sun for the current date and location.

SunPosition[datespec] gives the position of the Sun for the specified date.

SunPosition[locationspec] gives the positions of the Sun for the specified location.

SunPosition[locationspec,datespec] gives the position of the Sun for the specified date and location.

SunPosition[{{location1,date1},{location2,date2},…}] gives the positions of the Sun for all specified locations on the specified dates.

SunPosition[locationspec,datespec,func] uses func to determine what to return for extended locations.

Sunrise

Sunrise[] gives the time of the next sunrise for the current date and location.

Sunrise[datespec] gives the times of the next sunrise for the specified dates.

Sunrise[locationspec] gives the times of the next sunrise for the specified locations.

Sunrise[locationspec,datespec] gives the time of the next sunrise for the specified date and location.

Sunrise[{{location1,date1},{location2,date2},…}] gives the times of the next sunrise for all specified locations on the specified dates.

Sunrise[locationspec,datespec,func] uses func to determine what to return for extended locations.

Sunset

Sunset[] gives the time of the next sunset for the current date and location.

Sunset[datespec] gives the time of the next sunset for the specified dates.

Sunset[locationspec] gives the times of the next sunset for the specified locations.

Sunset[locationspec,datespec] gives the time of the next sunset for the specified date and location.

Sunset[{{location1,date1},{location2,date2},…}] gives the times of the next sunset for all specified locations on the specified dates.

Sunset[locationspec,datespec,func] uses func to determine what to return for extended locations.

SuperDagger

SuperDagger[expr] displays as expr†.

SuperMinus

SuperMinus[expr] displays as expr-.

SupernovaData

SupernovaData[entity,property] gives the value of the specified property for the supernova entity.

SupernovaData[{entity1,entity2,…},property] gives a list of property values for the specified supernova entities.

SupernovaData[entity,property,annotation] gives the specified annotation associated with the given property.

SuperPlus

SuperPlus[expr] displays as expr+.

Superscript

Superscript[x,y] is an object that formats as xy. 

Superset

Superset[x,y,…] displays as x⊃y⊃….

SupersetEqual

SupersetEqual[x,y,…] displays as x⊇y⊇….

SuperStar

SuperStar[expr] displays as expr*.

Surd

Surd[x,n] gives the real-valued nth root of x.

SurfaceArea

SurfaceArea[reg] gives the surface area of the three-dimensional region reg.

SurfaceArea[{x1,…,xn},{s,smin,ssmax},{t,tmin,tmax},{u,umin,umax}] gives the surface area of the parametrized region whose Cartesian coordinates xi are functions of s, t, u.

SurfaceArea[{x1,…,xn},{s,smin,ssmax},{t,tmin,tmax},{u,umin,umax},chart] interprets the xi as coordinates in the specified coordinate chart.

SurfaceColor

SurfaceColor[dcol] is a three-dimensional graphics directive which specifies that the surfaces which follow should act as diffuse reflectors of light with a color given by dcol. 

SurfaceColor[dcol,scol] specifies that a specular reflection component should be included, with a color given by scol. 

SurfaceColor[dcol,{scol,n}] specifies that the reflection should occur with specular exponent n. 

SurfaceColor[dcol,scol,gcol] specifies that a color gcol should be added as if there were an intrinsic glow in the polygon. 

SurfaceData

SurfaceData[entity,property] gives the value of the specified property for the surface entity.

SurfaceData[{entity1,entity2,…},property] gives a list of property values for the specified surface entities.

SurfaceData[entity, property, annotation] gives the specified annotation associated with the given property.

SurfaceGraphics

SurfaceGraphics[array] is a representation of a three-dimensional plot of a surface, with heights of each point on a grid specified by values in array. 

SurfaceGraphics[array,shades] represents a surface, whose parts are shaded according to the array shades. 

SurvivalDistribution

SurvivalDistribution[{e1,e2,…}] represents a survival distribution with event times ei.

SurvivalDistribution[{cw1,cw2,…}->{e1,e2,…}] represents a survival distribution where events ei occur with censor weights cwi.

SurvivalFunction

SurvivalFunction[dist,x] gives the survival function for the distribution dist evaluated at x.

SurvivalFunction[dist,{x1,x2,…}] gives the multivariate survival function for the distribution dist evaluated at {x1,x2,…}.

SurvivalFunction[dist] gives the survival function as a pure function.

SurvivalModel

SurvivalModel[…] represents the symbolic survival model obtained from functions like SurvivalModelFit.

SurvivalModelFit

SurvivalModelFit[{e1,e2,…}] creates a survival model for event times ei.

SuspendPacket

SuspendPacket[] is a WSTP packet used for synchronization with the Wolfram Language kernel.

SuzukiDistribution

SuzukiDistribution[μ,ν] represents the Suzuki distribution with shape parameters μ and ν.

SuzukiGroupSuz

SuzukiGroupSuz[] represents the sporadic simple Suzuki group Suz.

SwatchLegend

SwatchLegend[{col1,…},{lbl1,…}] generates a legend that associates swatches of colors coli with labels lbli.

SwatchLegend[{col1,…},Automatic] generates a legend with placeholder labels for the colors coli.

SwatchLegend[{lbl1,…}] represents a legend with inherited colors within visualization functions.

Switch

Switch[expr,form1,value1,form2,value2,…] evaluates expr, then compares it with each of the formi in turn, evaluating and returning the valuei corresponding to the first match found. 

Symbol

Symbol["name"] refers to a symbol with the specified name. 

SymbolName

SymbolName[symbol] gives the name of the specified symbol. 

SymletWavelet

SymletWavelet[] represents the Symlet wavelet of order 4.

SymletWavelet[n] represents the Symlet wavelet of order n.

Symmetric

Symmetric[{s1,…,sn}] represents the symmetry of a tensor that is symmetric in the slots si.

SymmetricGroup

SymmetricGroup[n] represents the symmetric group of degree n.

SymmetricKey

SymmetricKey[assoc] represents all the information needed for encryption, decryption, and other operations in a symmetric cryptographic system.

SymmetricMatrixQ

SymmetricMatrixQ[m] gives True if m is explicitly symmetric, and False otherwise. 

SymmetricPolynomial

SymmetricPolynomial[k,{x1,…,xn}] gives the kth elementary symmetric polynomial in the variables x1,…,xn.

SymmetricReduction

SymmetricReduction[f,{x1,…,xn}] gives a pair of polynomials {p,q} in x1,…,xn such that f==p+q, where p is the symmetric part and q is the remainder.

SymmetricReduction[f,{x1,…,xn},{s1,…,sn}] gives the pair {p,q} with the elementary symmetric polynomials in p replaced by s1,…,sn.

Symmetrize

Symmetrize[tensor,sym] returns the symmetrization of tensor under the symmetry sym.

SymmetrizedArray

SymmetrizedArray[{pos1->val1,pos2->val2,…},dims,sym] yields an array of dimensions dims whose entries are given by those in the rules posi->vali or through the symmetry sym.

SymmetrizedArray[list] yields a symmetrized array version of list.

SymmetrizedArrayRules

SymmetrizedArrayRules[sa] returns a list of rules posi->vali of the symmetrized array sa.

SymmetrizedArrayRules[a,sym] returns a list of rules posi->vali of the array a after being symmetrized with symmetry sym.

SymmetrizedDependentComponents

SymmetrizedDependentComponents[comp,sym] gives the list of components that are equivalent to the component comp by the symmetry sym.

SymmetrizedIndependentComponents

SymmetrizedIndependentComponents[dims,sym] gives the list of independent components of an array of dimensions dims with the symmetry sym.

SymmetrizedReplacePart

SymmetrizedReplacePart[sa,{pos1->val1,pos2->val2,…}] replaces independent values of the symmetrized array sa as given by the rules posi->vali.

Synonyms

Synonyms["word"] returns the synonyms associated with the specified word.

SyntaxInformation

SyntaxInformation[f] gives information used to generate syntax coloring and other advisories when f[…] is entered as input. 

SyntaxLength

SyntaxLength["string"] finds the number of characters starting at the beginning of a string that correspond to syntactically correct input for a single Wolfram Language expression. 

SyntaxPacket

SyntaxPacket[integer] is a WSTP packet where integer indicates the position at which a syntax error was detected in the input line.

SyntaxQ

SyntaxQ["string"] returns True if the string corresponds to syntactically correct input for a single Wolfram Language expression, and returns False otherwise. 

SyntaxQ["string",form] uses interpretation rules corresponding to the specified form.

SynthesizeMissingValues

SynthesizeMissingValues[{example1,example2,…}] replaces missing values in each example by generated values.

SynthesizeMissingValues[dist,data] uses the distribution dist to generate values.

TabFilling

TabFilling is an option for character selections that specifies how a Tab character is represented on the screen.

Table

Table[expr,n] generates a list of n copies of expr. 

Table[expr,{i,imax}] generates a list of the values of expr when i runs from 1 to imax. 

Table[expr,{i,imin,imax}] starts with i=imin. 

Table[expr,{i,imin,imax,di}] uses steps di. 

Table[expr,{i,{i1,i2,…}}] uses the successive values i1, i2, ….

Table[expr,{i,imin,imax},{j,jmin,jmax},…] gives a nested list. The list associated with i is outermost.

TableAlignments

TableAlignments is an option for TableForm and MatrixForm which specifies how entries in each dimension should be aligned. 

TableDepth

TableDepth is an option for TableForm and MatrixForm that specifies the maximum number of levels to be printed in tabular or matrix format. 

TableDirections

TableDirections is an option for TableForm and MatrixForm which specifies whether successive dimensions should be arranged as rows or columns. 

TableHeadings

TableHeadings is an option for TableForm and MatrixForm that gives the labels to be printed for entries in each dimension of a table or matrix. 

TableSpacing

TableSpacing is an option for TableForm and MatrixForm that specifies how many spaces should be left between each successive row or column. 

TableView

TableView[{{expr11,expr12,…},{expr21,expr22,…},…}] displays as a spreadsheet-like table view for editing and viewing exprij.

TabSpacings

TabSpacings is an option for character selections that specifies the number of spaces in ems that the cursor advances when the Tab key is pressed.

TaggingRules

TaggingRules is an option for selections that specifies a list of strings to be associated with a selection.

TagSet

f/:lhs=rhs assigns rhs to be the value of lhs, and associates the assignment with the symbol f. 

TagSetDelayed

f/:lhs:=rhs assigns rhs to be the delayed value of lhs, and associates the assignment with the symbol f. 

TagUnset

f/:lhs=. removes any rules defined for lhs, associated with the symbol f. 

Take

Take[list,n] gives the first n elements of list. 

Take[list,-n] gives the last n elements of list. 

Take[list,{m,n}] gives elements m through n of list. 

Take[list,seq1,seq2,…] gives a nested list in which elements specified by seqi are taken at level i in list. 

TakeDrop

TakeDrop[list,n] gives the pair {list1,list2}, where list1 contains the first n elements of list and list2 contains the rest.

TakeDrop[list,seq] gives the pair {Take[list,seq],Drop[list,seq]}.

TakeLargest

TakeLargest[data,n] gives the n largest elements of data, sorted in descending order.

TakeLargest[data->prop,n] gives the property prop for the n largest elements in data.

TakeLargest[data,n,p] uses the ordering function p for sorting.

TakeLargest[n] represents an operator form of TakeLargest that can be applied to an expression.

TakeLargestBy

TakeLargestBy[data,f,n] gives the n elements ei in data for which f[ei] is largest, sorted in descending order.

TakeLargestBy[data->prop,f,n] gives the property prop for the n elements in data for which f[ei] is largest.

TakeLargestBy[data,f,n,p] uses the ordering function p for sorting.

TakeLargestBy[f,n] represents an operator form of TakeLargestBy that can be applied to an expression. 

TakeList

TakeList[list,{n1,n2,…}] gives the list of results obtained by successively taking ni elements from list.

TakeList[list,{seq1,seq2,…}] successively uses the sequence specifications seqi. 

TakeList[list,seqs1,seqs2,…] gives a nested list in which elements specified by the lists seqsi are taken at level i in list.

TakeSmallest

TakeSmallest[data,n] gives the n smallest elements of data, sorted in ascending order.

TakeSmallest[data->prop,n] gives the property prop for the n smallest elements in data.

TakeSmallest[data,n,p] uses the order function p for sorting.

TakeSmallest[n] represents an operator form of TakeSmallest that can be applied to an expression.

TakeSmallestBy

TakeSmallestBy[data,f,n] gives the n elements ei in data for which f[ei] is smallest, sorted in ascending order.

TakeSmallestBy[data->prop,f,n] gives the property prop for the n elements in data for which f[ei] is smallest.

TakeSmallestBy[data,f,n,p] uses the ordering function p for sorting.

TakeSmallestBy[f,n] represents an operator form of TakeSmallestBy that can be applied to an expression. 

TakeWhile

TakeWhile[list,crit] gives elements ei from the beginning of list, continuing so long as crit[ei] is True.

Tally

Tally[list] tallies the elements in list, listing all distinct elements together with their multiplicities.

Tally[list,test] uses test to determine whether pairs of elements should be considered equivalent, and gives a list of the first representatives of each equivalence class, together with their multiplicities.

Tan

Tan[z] gives the tangent of z.

Tanh

Tanh[z] gives the hyperbolic tangent of z.

TargetDevice

TargetDevice is an option for certain functions that specifies on which device the computation should be attempted.

TargetFunctions

TargetFunctions is an option for functions such as ComplexExpand and FindDistribution that specifies what functions to attempt to generate in the output. 

TargetUnits

TargetUnits is an option used to specify the desired output units for visualization functions operating on Quantity expressions.

TaskAbort

TaskAbort[task] generates an interrupt to abort the current execution of a task.

TaskExecute

TaskExecute[task] immediately executes an instance of the specified task, independently of any schedule given.

TaskObject

TaskObject[spec] is an object that represents a background task.

TaskRemove

TaskRemove[task] terminates and removes the specified task.

TaskResume

TaskResume[task] resumes execution of the specified task.

Tasks

Tasks[type] gives a list of TaskObject expressions representing currently submitted tasks of given type.

TaskSuspend

TaskSuspend[task] suspends the execution of the specified task.

TaskWait

TaskWait[task] waits for the specified task to be completely finished. 

TautologyQ

TautologyQ[bf] gives True if all combinations of values of variables make the Boolean function bf yield True.

TautologyQ[expr,{a1,a2,…}] gives True if all combinations of values of the ai make the Boolean expression expr yield True.

TelegraphProcess

TelegraphProcess[μ] represents a telegraph process with rate μ.

TemplateApply

TemplateApply[template] applies a template, evaluating all template elements it contains.

TemplateApply[template,args] applies a template, using args to fill slots in the template.

TemplateExpression

TemplateExpression[expr] represents an expression held until a template is applied, and then evaluated.

TemplateIf

TemplateIf[condition,tclause] represents an element of a template object that inserts tclause if the condition evaluates to True.

TemplateIf[condition,tclause,fclause] inserts fclause if the condition does not evaluate to True.

TemplateObject

TemplateObject[expr] represents a template object to be applied using functions like TemplateApply.

TemplateObject[form,args] yields a TemplateObject with arguments, suitable for cloud deployment or other evaluation.

TemplateSequence

TemplateSequence[body,list] represents an element of a template object that yields a sequence consisting of body applied to each element in list.

TemplateSlot

TemplateSlot[n] represents a template slot to be filled from the nth argument when the template is applied.

TemplateSlot[name] represents a template slot to be filled from an element with key name in an association appearing in the first argument.

TemplateWith

TemplateWith["name"->value,expr] represents an element of a template object that evaluates expr after replacing TemplateSlot["name"] with value.

TemplateWith[{name1->value1,name2->value2, …},expr] evaluates expr with a list of key-value pairs.

TemporalData

TemporalData[{v1,v2,…},tspec] represents temporal data with values vi at times specified by tspec.

TemporalData[{{v11,v12,…},{v21,v22,…},…},tspec] represents a temporal data collection with values vij at times specified by tspec.

TemporalData[{{t1,v1},{t2,v2}…}] represents temporal data specified by time-value pairs {ti,vi}.

TemporalData[{{{t11,v11},{t12,v12}…},{{t21,v21},{t22,v22},…},…}] represents a temporal data collection given as lists of time-value pairs {tij,vij}.

TemporalRegularity

TemporalRegularity is an option for TemporalData, TimeSeries, and EventSeries that controls whether the paths are assumed to be uniformly spaced in time.

Temporary

Temporary is an attribute assigned to symbols which are created as local variables by Module. 

TensorContract

TensorContract[tensor,{{s11,s12},{s21,s22},…}] yields the contraction of tensor in the pairs {si1,si2} of slots.

TensorDimensions

TensorDimensions[tensor] gives the list of dimensions of tensor.

TensorExpand

TensorExpand[texpr] expands out tensor-related products in the symbolic tensor expression texpr.

TensorProduct

TensorProduct[tensor1,tensor2,…] represents the tensor product of the tensori.

TensorRank

TensorRank[tensor] gives the rank of tensor.

TensorReduce

TensorReduce[texpr] attempts to return a canonical form for the symbolic tensor expression texpr.

TensorSymmetry

TensorSymmetry[tensor] gives the symmetry of tensor under permutations of its slots.

TensorSymmetry[tensor,slots] gives the symmetry under permutation of the specified list of slots.

TensorTranspose

TensorTranspose[tensor,perm] represents the tensor obtained by transposing the slots of tensor as given by the permutation perm.

TensorWedge

TensorWedge[tensor1,tensor2,…] represents the antisymmetrized tensor product of the tensori.

TestID

TestID is an option to TestCreate, VerificationTest and IntermediateTest that specifies a string used as an identifier for the test.

TestReport

TestReport["file"] gives a report of the results of the tests from a file.

TestReport[{test1,test2,…}] gives a report of the results of the testi.

TestReport[{report1,report2,…}] gives a unified report by merging all test reports reporti.

TestReportObject

TestReportObject[…] gives an object that represents the results of TestReport.

TestResultObject

TestResultObject[…] gives an object that represents the results of a VerificationTest.

Tetrahedron

Tetrahedron[] represents a regular tetrahedron centered at the origin with unit edge length.

Tetrahedron[l] represents a tetrahedron with edge length l.

Tetrahedron[{θ,ϕ},…] represents a tetrahedron rotated by an angle θ with respect to the z axis and angle ϕ with respect to the y axis.

Tetrahedron[{x,y,z},…] represents a tetrahedron centered at {x,y,z}.

Tetrahedron[{p1,p2,p3,p4}] represents a general filled tetrahedron with corners p1, p2, p3 and p4.

Tetrahedron[{{p1,1,p1,2,p1,3,p1,4},{p2,1,…},…}] represents a collection of tetrahedra.

TeXForm

TeXForm[expr] prints as a TeX version of expr. 

Text

Text[expr] displays with expr in plain text format. 

Text[expr,coords] is a graphics primitive that displays the textual form of expr centered at the point specified by coords. 

TextAlignment

TextAlignment is an option for Cell, Style and related constructs which specifies how successive lines of text should be aligned. 

TextCases

TextCases[text,form] gives a list of all cases of text identified as being of type form that appear in text.

TextCases[text,{form1,form2,…}] gives an association of results for all the types formi. 

TextCases[text,formspec->prop] gives the specified property for each result found.

TextCases[text,formspec->{prop1,prop2,…}] gives a list of properties for each result found.

TextCases[text,spec,n] gives the first n cases found.

TextContents

TextContents[text] gives a dataset of information about entities, dates, quantities and other content-related elements found in text.

TextContents[text,form] searches for cases of the type form.

TextContents[text,{form1,form2,…}] searches for cases of types form1, form2, …

TextContents[text,forms,props] includes the property props for each object in the dataset produced.

TextElement

TextElement[text,props] represents an element of text with the specified properties.

TextElement[{elem1,elem2,…},props] represents text formed from a sequence of elements.

TextElement[elems] represents text where no properties are specified. 

TextGrid

TextGrid[{{expr11,expr12,…},{expr21,expr22,…},…}] is an object that formats exprij textually and arranged in a two-dimensional grid. 

TextJustification

TextJustification is an option for Cell and Inset which specifies how much lines of text can be stretched in order to make them be the same length. 

TextPosition

TextPosition[text,form] gives a list of the starting and ending positions at which instances of form occur in text.

TextPosition[text,{form1,form2,…}] gives an association of results for all the types formi.

TextPosition[text,formspec,n] gives the positions of the first n cases found.

TextRecognize

TextRecognize[image] recognizes text in image and returns it as a string.

TextRecognize[image,level] returns a list of strings at the specified structural level.

TextRecognize[image,level,prop] returns prop for text at the given level.

TextRecognize[video,…] recognizes text in frames of video.

TextSearch

TextSearch[source,form] searches for files referenced by source that contain text matching form.

TextSearch[source,form,"prop"] returns the property prop for each result.

TextSearchReport

TextSearchReport[source,form] gives a structured report of files referenced by source that contain text matching form.

TextSentences

TextSentences["string"] gives a list of the runs of characters identified as sentences in string.

TextSentences["string",n] gives the first n sentences in string.

TextString

TextString[expr] gives a human-readable string representation of expr.

TextStructure

TextStructure["text"] generates a nested collection of TextElement objects representing the grammatical structure of natural language text.

TextStructure["text",form] generates a representation of the type specified by form of the grammatical structure of text.

TextStyle

TextStyle is an option for graphics functions and for Text which specifies the default style and font options with which text should be rendered. 

TextTranslation

TextTranslation["text"] translates text into the current default language. 

TextTranslation["text",lang] translates text into the language specified by lang.

TextTranslation["text",lang1->lang2] translates text from language lang1 to lang2.

Texture

Texture[obj] is a graphics directive that specifies that obj should be used as a texture on faces of polygons and other filled graphics objects. 

Texture[obj,map] specifies the projection mapping map to assign to vertices of 3D graphics objects.

TextureCoordinateFunction

TextureCoordinateFunction is an option to Plot3D and similar functions that specifies a function that computes texture coordinates.

TextureCoordinateScaling

TextureCoordinateScaling is an option to Plot3D and similar functions that specifies whether arguments supplied to a texture coordinate function should be scaled to lie between 0 and 1.

TextWords

TextWords["string"] gives a list of the runs of characters identified as words in string.

TextWords["string",n] gives the first n words in string.

Therefore

Therefore[x,y] displays as x∴y.

ThermodynamicData

ThermodynamicData["name","property"] gives the value of the specific property for the substance "name".

ThermodynamicData["name","property",{parameter1->quantity1,parameter2->quantity}] gives the value of the specific property for the substance "name" at the specified parameters.

Thick

Thick is a graphics directive that specifies that lines which follow should be drawn thick.

Thickness

Thickness[r] is a graphics directive which specifies that lines which follow are to be drawn with thickness r. The thickness r is given as a fraction of the horizontal plot range. 

Thin

Thin is a graphics directive that specifies that lines which follow should be drawn thin.

Thinning

Thinning[image] finds the skeletons of foreground regions in image by applying morphological thinning until convergence.

Thinning[image,n] performs n iterations of morphological thinning.

Thinning[image,n,t] treats values above t as foreground.

ThisLink

ThisLink is used in patterns for external packages to distinguish between several instances of the same package.

ThompsonGroupTh

ThompsonGroupTh[] represents the sporadic simple Thompson group Th.

Thread

Thread[f[args]] "threads" f over any lists that appear in args. 

Thread[f[args],h] threads f over any objects with head h that appear in args. 

Thread[f[args],h,n] threads f over objects with head h that appear in the first n args. 

ThreadingLayer

ThreadingLayer[f] represents a net layer that takes several input arrays and applies a function f to corresponding array elements.

ThreadingLayer[f,bspec] allows array shapes to be conformed according to broadcasting specification bspec.

ThreeJSymbol

ThreeJSymbol[{j1,m1},{j2,m2},{j3,m3}] gives the values of the Wigner 3‐j symbol. 

Threshold

Threshold[data] thresholds data by replacing values close to zero by zero.

Threshold[data,tspec] thresholds data using threshold specification tspec.

Threshold[image,…] replaces small values of image by zero. 

Threshold[sound,…] replaces small values of sound by zero. 

Through

Through[p[f,g,…][x,y,…]] gives p[f[x,y,…],g[x,y,…],…]. 

Through[expr,h] performs the transformation wherever h occurs in the head of expr. 

Throw

Throw[value] stops evaluation and returns value as the value of the nearest enclosing Catch.

Throw[value,tag] is caught only by Catch[expr,form], where tag matches form.

Throw[value,tag,f] returns f[value,tag] as the top-level value if no appropriate Catch is found.

ThueMorse

ThueMorse[n] gives the nth term in the Thue–Morse sequence.

Thumbnail

Thumbnail[image] gives a thumbnail version of an image.

Thumbnail[file] gives a thumbnail of an image stored in a file.

Thumbnail[url] gives a thumbnail of an image stored at a URL.

Thumbnail[spec,size] gives a thumbnail with the specified maximum pixel size.

Thursday

Thursday is a day of the week.

TickDirection

TickDirection is an option for AxisObject that specifies where the ticks are drawn relative to the axis.

TickLabelOrientation

TickLabelOrientation is an option for AxisObject that specifies how the tick labels should be oriented relative to the axis.

TickLabelPositioning

TickLabelPositioning is an option for AxisObject that specifies how the tick labels should be positioned relative to the ticks.

TickLabels

TickLabels is an option for AxisObject that specifies how the tick marks should be labeled.

TickLengths

TickLengths is an option for AxisObject that specifies the lengths of the tick marks.

TickPositions

TickPositions is an option for AxisObject that specifies where the tick marks should be positioned.

Ticks

Ticks is an option for graphics functions that specifies tick marks for axes. 

TicksStyle

TicksStyle is an option for graphics functions which specifies how ticks should be rendered.

TideData

TideData[spec] returns the tidal properties for a location or a set of tidal parameters.

TideData[spec,prop] returns the specified property for the location or tidal parameters indicated.

TideData[spec,prop,datespec] returns the value of a specified property for a date or set of dates.

Tilde

Tilde[x,y,…] displays as x∼y∼….

TildeEqual

TildeEqual[x,y,…] displays as x≃y≃….

TildeFullEqual

TildeFullEqual[x,y,…] displays as x≅y≅….

TildeTilde

TildeTilde[x,y,…] displays as x≈y≈….

TimeConstrained

TimeConstrained[expr,t] evaluates expr, stopping after t seconds. 

TimeConstrained[expr,t,failexpr] returns failexpr if the time constraint is not met. 

TimeConstraint

TimeConstraint is an option for various functions that specifies the maximum time to spend doing a particular operation. 

TimeDirection

TimeDirection is an option for Sunrise, Sunset, and related functions that specifies whether the next or last event should be returned.

TimeGoal

TimeGoal is an option for various functions that specifies how long to spend doing a particular operation.

TimelinePlot

TimelinePlot[{date1,date2,…}] makes a timeline plot with dates date1, date2, …. 

TimelinePlot[{event1,event2,…}] makes a timeline plot with events event1, event2, …. 

TimelinePlot[{data1,data2,…}] makes a timeline plot from multiple event datasets datai.

TimeObject

TimeObject[] represents the current time.

TimeObject[{h,m,s}] represents a time object of standard normalized form.

TimeObject[date] gives the time component of the specified date representation.

TimeObject[rtime,gran] gives the time object of granularity gran that includes the reference time rtime.

TimeObjectQ

TimeObjectQ[expr] gives True if expr is a TimeObject with valid arguments, and False otherwise.

TimeRemaining

TimeRemaining[] gives the number of seconds remaining until the earliest enclosing TimeConstrained will request the current computation to stop.

Times

x*y*z, x×y×z, or x y z represents a product of terms. 

TimesBy

x*=c multiplies x by c and returns the new value of x. 

TimeSeries

TimeSeries[{{t1,v1},{t2,v2}…}] represents a time series specified by time-value pairs {ti,vi}.

TimeSeries[{v1,v2,…},tspec] represents a time series with values vi at times specified by tspec.

TimeSeriesAggregate

TimeSeriesAggregate[tseries,dt] computes the mean value of tseries over non-overlapping windows of width dt.

TimeSeriesAggregate[tseries,dt,f] applies the function f to the values of tseries in non-overlapping windows of width dt.

TimeSeriesForecast

TimeSeriesForecast[tproc,data,k] gives the k-step-ahead forecast beyond data according to the time series process tproc.

TimeSeriesForecast[tsmod,k] gives the k-step-ahead forecast for TimeSeriesModel tsmod. 

TimeSeriesInsert

TimeSeriesInsert[tseries,{t,v}] inserts a value v at time t in the time series tseries.

TimeSeriesInsert[tseries1,tseries2] inserts the time-value pairs from tseries2 into tseries1.

TimeSeriesInvertibility

TimeSeriesInvertibility[tproc] gives conditions for the time series process tproc to be invertible. 

TimeSeriesMap

TimeSeriesMap[f,tseries] applies f to the values in tseries.

TimeSeriesMapThread

TimeSeriesMapThread[f,tseries] gives {{t1,f[t1,x1]},{t2,f[t2,x2]},…} for the time series tseries.

TimeSeriesMapThread[f,tseries,{{a1,a2,…},{b1,b2,…},…}] gives {{t1,f[t1,x1,a1,b1,…]},{t2,f[t2,x2,a2,b2,…]},…} for the time series tseries.

TimeSeriesModel

TimeSeriesModel[…] represents the symbolic time series model obtained from TimeSeriesModelFit.

TimeSeriesModelFit

TimeSeriesModelFit[data] constructs a time series model for data from an automatically selected model family.

TimeSeriesModelFit[data,mspec] constructs a time series model for data from a model family specified by mspec.

TimeSeriesResample

TimeSeriesResample[tseries] uniformly resamples tseries according to its minimum time increment.

TimeSeriesResample[tseries,rspec] resamples tseries according to rspec.

TimeSeriesRescale

TimeSeriesRescale[tseries,{tmin,tmax}] rescales the times in time series tseries to run from tmin to tmax.

TimeSeriesRescale[tseries,{tmin,tmax,tu}] rescales times in units of tu including "Month", "Quarter", or "Year".

TimeSeriesShift

TimeSeriesShift[tseries,shift] shifts the time series tseries to the left or right according to shift.

TimeSeriesThread

TimeSeriesThread[f,{tseries1,tseries2,…}] combines the tseriesi using the function f.

TimeSeriesWindow

TimeSeriesWindow[tseries,{tmin,tmax}] gives the elements of the time series tseries that fall between tmin and tmax.

TimeSeriesWindow[tseries,windowspec] gives the elements of the time series tseries that satisfy the window specification windowspec.

TimeValue

TimeValue[s,i,t] calculates the time value of a security s at time t for an interest specified by i.

TimeWarpingCorrespondence

TimeWarpingCorrespondence[s1,s2] gives the time warping (DTW) similarity path between sequences s1 and s2.

TimeWarpingCorrespondence[s1,s2,r] uses a window of radius r for local search.

TimeWarpingDistance

TimeWarpingDistance[s1,s2] gives the dynamic time warping (DTW) distance between sequences s1 and s2.

TimeWarpingDistance[s1,s2,r] uses a window of radius r for local search.

TimeZone

TimeZone is an option for DateObject, DateString, and related functions that specifies the time zone to use for dates and times. 

TimeZoneConvert

TimeZoneConvert[time,timezone] converts the date or time object time to the specified time zone timezone.

TimeZoneConvert[time] converts to the current $TimeZone value.

TimeZoneConvert[{time1,…,timen},timezone] converts time1 through timen to the specified timezone.

TimeZoneOffset

TimeZoneOffset[tz] gives the numeric offset between the time zone tz and GMT on the current date.

TimeZoneOffset[loc] gives the numeric offset between the time zone for the location loc and GMT.

TimeZoneOffset[tz,base] gives the numeric offset between tz and the specified base time zone.

TimeZoneOffset[tz,date] gets a list of possible time zone offsets for tz at the given date list.

TimeZoneOffset[tz,base,date] gives the numeric offset between tz and base on the specified date.

Timing

Timing[expr] evaluates expr, and returns a list of the time in seconds used, together with the result obtained. 

Tiny

Tiny is a style or option setting that specifies that objects should be tiny.

TitsGroupT

TitsGroupT[] represents the simple Tits group T.

ToCharacterCode

ToCharacterCode["string"] gives a list of the integer codes corresponding to the characters in a string. 

ToCharacterCode["string","encoding"] gives integer codes according to the specified encoding. 

ToColor

ToColor[color, form] converts color to form if form is GrayLevel, RGBColor or CMYKColor. Otherwise form[color] is evaluated and the result is expected to be a valid color directive.

ToContinuousTimeModel

ToContinuousTimeModel[lsys] gives the continuous-time approximation of the discrete-time systems models lsys.

ToContinuousTimeModel[tfm,s] specifies the transform variable s.

ToDate

ToDate[time] converts an absolute time in seconds since the beginning of January 1, 1900 to a date of the form {y,m,d,h,m,s}. 

Today

Today gives a DateObject representing the current day.

ToDiscreteTimeModel

ToDiscreteTimeModel[lsys,τ] gives the discrete-time approximation, with sampling period τ, of the continuous-time systems models lsys.

ToDiscreteTimeModel[tfm,τ,z] specifies the transform variable z.

ToEntity

ToEntity[expr] returns an entity object corresponding to the given expression.

ToEntity[expr,type] returns an entity object of the specified type corresponding to expr.

ToeplitzMatrix

ToeplitzMatrix[n] gives the n×n Toeplitz matrix with first row and first column being successive integers.

ToeplitzMatrix[{c1,c2,…,cn}] gives the Toeplitz matrix whose first column consists of entries c1, c2, ….

ToeplitzMatrix[{c1,c2,…,cm},{r1,r2,…, rn}] gives the Toeplitz matrix with entries ci down the first column, and ri across the first row.

ToFileName

ToFileName["directory","name"] assembles a full file name from a directory name and a file name. 

ToFileName[{dir1,dir2,…},name] assembles a full file name from a hierarchy of directory names. 

ToFileName[{dir1,dir2,…}] assembles a single directory name from a hierarchy of directory names. 

Together

Together[expr] puts terms in a sum over a common denominator, and cancels factors in the result. 

ToInvertibleTimeSeries

ToInvertibleTimeSeries[tproc] returns an invertible version of a time series process tproc.

TokenWords

TokenWords is an option for Read and related functions which gives a list of token words to be used to delimit words. 

Tolerance

Tolerance is an option for various numerical options which specifies the tolerance that should be allowed in computing results.

ToLowerCase

ToLowerCase[string] yields a string in which all letters have been converted to lowercase. 

Tomorrow

Tomorrow gives a DateObject representing the following day.

ToNumberField

ToNumberField[a,θ] expresses the algebraic number a in the number field generated by θ. 

ToNumberField[{a1,a2,…},θ] expresses the ai in the field generated by θ.

ToNumberField[{a1,a2,…}] expresses the ai in a common extension field generated by a single algebraic number.

TooBig

TooBig is an internal symbol.

ToonShading

ToonShading[] is a three-dimensional graphics directive specifying that surfaces that follow are to be drawn to emulate two-dimensional flat objects.

ToonShading[col] uses the color col as base color.

ToonShading[{dcol,bcol,hcol}] uses the dark color dcol, the base color bcol and highlight color hcol.

ToonShading[{w1,w2,w3}->{dcol,bcol,hcol}] uses the colors dcol, bcol and hcol weighted by the wi.

ToonShading["scheme"] uses the specified discrete color scheme in ColorData.

Top

Top is a symbol that represents the top for purposes of alignment and positioning. 

TopHatTransform

TopHatTransform[image,ker] gives the morphological top-hat transform of image with respect to structuring element ker.

TopHatTransform[image,r] gives the top-hat transform with respect to a range-r square.

TopHatTransform[data,…] applies top-hat transform to an array of data.

ToPolarCoordinates

ToPolarCoordinates[{x,y}] gives the {r,θ} polar coordinates corresponding to the Cartesian coordinates {x,y}.

ToPolarCoordinates[{x1,x2,…,xn}] gives the hyperspherical coordinates corresponding to the Cartesian coordinates {x1,x2,…,xn}.

TopologicalSort

TopologicalSort[g] gives a list of vertices of g in topologically sorted order for a directed acyclic graph g.

TopologicalSort[{v->w,…}] uses rules v->w to specify the graph g. 

ToRadicals

ToRadicals[expr] attempts to express all Root objects in expr in terms of radicals. 

ToRules

ToRules[eqns] takes logical combinations of equations, in the form generated by Roots and Reduce, and converts them to lists of rules, of the form produced by Solve. 

Torus

Torus[{x,y,z},{rinner,router}] represents a torus centered at {x,y,z} with inner radius rinner and outer radius router.

ToSphericalCoordinates

ToSphericalCoordinates[{x,y,z}] gives the {r,θ,ϕ} spherical coordinates corresponding to the Cartesian coordinates {x,y,z}.

ToString

ToString[expr] gives a string corresponding to the printed form of expr in OutputForm. 

ToString[expr,form] gives the string corresponding to output in the specified form. 

Total

Total[list] gives the total of the elements in list. 

Total[list,n] totals all elements down to level n. 

Total[list,{n}] totals elements at level n. 

Total[list,{n1,n2}] totals elements at levels n1 through n2. 

TotalLayer

TotalLayer[] represents a net layer taking a list of input arrays and performing elementwise addition on them.

TotalVariationFilter

TotalVariationFilter[data] iteratively reduces noise while preserving rapid transitions in data.

TotalVariationFilter[data,param] assumes a regularization parameter value param.

TotalWidth

TotalWidth is an option that can be set for output streams to specify the maximum total number of characters of text that should be printed for each output expression. Short forms of expressions are given if the number of characters needed to print the whole expression is too large. 

TouchscreenAutoZoom

TouchscreenAutoZoom is an option for Manipulate and Graphics3D that determines whether the interface zooms to full-screen when it is activated by touching it on supported touch screen platforms.

TouchscreenControlPlacement

TouchscreenControlPlacement is an option for Manipulate that determines the placement of the slide-out control panel on supported touchscreen platforms.

ToUpperCase

ToUpperCase[string] yields a string in which all letters have been converted to uppercase. 

TourVideo

TourVideo[input,{step1,step2,…}] generates a video by taking a tour at steps stepi around graphics.

TourVideo[input,{{t1,step1},{t2,step2},…}] takes a tour with steps stepi at times ti around graphics.

TourVideo[input,func] samples the function func to generate step specifications for each frame.

Tr

Tr[list] finds the trace of the matrix or tensor list. 

Tr[list,f] finds a generalized trace, combining terms with f instead of Plus. 

Tr[list,f,n] goes down to level n in list. 

Trace

Trace[expr] generates a list of all expressions used in the evaluation of expr. 

Trace[expr,form] includes only those expressions that match form. 

Trace[expr,s] includes all evaluations that use transformation rules associated with the symbol s. 

TraceAbove

TraceAbove is an option for Trace and related functions which specifies whether to include evaluation chains which contain the evaluation chain containing the pattern form sought. 

TraceAction

TraceAction is an option for TracePrint and TraceDialog that specifies the function to be applied to each expression they trace.

TraceBackward

TraceBackward is an option for Trace and related functions that specifies whether to include preceding expressions on the evaluation chain that contains the pattern form sought. 

TraceDepth

TraceDepth is an option for Trace and related functions which specifies the maximum nesting of evaluation chains that are to be included. 

TraceDialog

TraceDialog[expr] initiates a dialog for every expression used in the evaluation of expr. 

TraceDialog[expr,form] initiates a dialog only for expressions which match form. 

TraceDialog[expr,s] initiates dialogs only for expressions whose evaluations use transformation rules associated with the symbol s. 

TraceForward

TraceForward is an option for Trace and related functions which specifies whether to include later expressions on the evaluation chain that contains the pattern form sought. 

TraceInternal

TraceInternal is an option for Trace and related functions which, if True or False, specifies whether to trace evaluations of expressions generated internally by Mathematica. The intermediate Automatic setting traces a selected set of internal evaluations including Messages and sets or unsets of visible symbols.

TraceLevel

TraceLevel[] returns the level currently being traced when it appears within Trace and related functions.

TraceOff

TraceOff is an option for Trace and related functions which specifies forms inside which tracing should be switched off. 

TraceOn

TraceOn is an option for Trace and related functions which specifies when tracing should be switched on. 

TraceOriginal

TraceOriginal is an option for Trace that specifies whether to test the form of each expression before its head and arguments are evaluated. 

TracePrint

TracePrint[expr] prints all expressions used in the evaluation of expr. 

TracePrint[expr,form] includes only those expressions which match form. 

TracePrint[expr,s] includes all evaluations which use transformation rules associated with the symbol s. 

TraceScan

TraceScan[f,expr] applies f to all expressions used in the evaluation of expr. 

TraceScan[f,expr,form] includes only those expressions which match form. 

TraceScan[f,expr,s] includes all evaluations which use transformation rules associated with the symbol s. 

TraceScan[f,expr,form,fp] applies f before evaluation and fp after evaluation to expressions used in the evaluation of expr. 

TrackedSymbols

TrackedSymbols is an option to Refresh, Manipulate, and related functions that specifies which symbols should trigger updates when their values are changed.

TrackingFunction

TrackingFunction is an option for Manipulate controls that specifies functions to use during interactive changing or editing.

TracyWidomDistribution

TracyWidomDistribution[β] represents a Tracy–Widom distribution with Dyson index β.

TradingChart

TradingChart[{{date1,{open1,high1,low1,close1,volume1}},…}] makes a chart showing prices and volume for each date. 

TradingChart[{"name",daterange}] makes a financial chart for the financial entity "name" over the daterange. 

TradingChart[{…},{ind1,ind2,…}] makes a financial chart with indicators ind1, ind2, …. 

TraditionalForm

TraditionalForm[expr] prints as an approximation to the traditional mathematical notation for expr. 

TraditionalFunctionNotation

TraditionalFunctionNotation is an option for selections that specifies whether input of the form f(x) is interpreted by the kernel as a function or as a product.

TrainingProgressCheckpointing

TrainingProgressCheckpointing is an option for NetTrain that specifies how to save copies of the net during training.

TrainingProgressFunction

TrainingProgressFunction is an option for NetTrain that specifies a function to run periodically during training.

TrainingProgressMeasurements

TrainingProgressMeasurements is an option for NetTrain that specifies measurements to make while training is in progress.

TrainingProgressReporting

TrainingProgressReporting is an option for NetTrain and related functions that specifies how to report the progress of training.

TrainingStoppingCriterion

TrainingStoppingCriterion is an option for NetTrain that specifies a criterion for stopping training early in order to prevent overfitting.

TrainingUpdateSchedule

TrainingUpdateSchedule is an option for NetTrain that specifies which arrays of the network can be updated at each step of the optimization process.

TrainTextContentDetector

TrainTextContentDetector[{text1->{span1->class1,…},…}] trains a ContentDetectorFunction[…] based on the examples given.

TransferFunctionCancel

TransferFunctionCancel[tfm] cancels common poles and zeros in the TransferFunctionModel tfm.

TransferFunctionCancel[tfm,crit] cancels only common pole-zero pairs ei for which crit[ei] is True.

TransferFunctionExpand

TransferFunctionExpand[tfm] expands polynomial terms in the numerators and denominators of the TransferFunctionModel tfm.

TransferFunctionFactor

TransferFunctionFactor[tfm] factors the polynomial terms in the numerators and denominators of the TransferFunctionModel tfm.

TransferFunctionModel

TransferFunctionModel[g[s],s] represents the model of the transfer-function matrix g[s] with complex variable s.

TransferFunctionModel[{n[s],d[s]},s] specifies the numerator n[s] and denominator d[s] of a transfer-function model.

TransferFunctionModel[{z,p,g},s] specifies the zeros z, poles p, and gain g of a transfer-function model.

TransferFunctionModel[sys] gives the transfer-function model of the systems model sys.

TransferFunctionPoles

TransferFunctionPoles[tfm] gives a matrix of roots of the denominators in the TransferFunctionModel tfm.

TransferFunctionPoles[tfm,reg] only gives the roots inside the region reg on the complex plane.

TransferFunctionTransform

TransferFunctionTransform[f,tf] transforms the TransferFunctionModel object tf using the transformation function f.

TransferFunctionZeros

TransferFunctionZeros[tfm] gives a matrix of roots of the numerators in the TransferFunctionModel tfm.

TransferFunctionZeros[tfm,reg] only gives the roots inside the region reg on the complex plane.

TransformationClass

TransformationClass is an option that specifies the class of geometric transformations to be used.

TransformationFunction

TransformationFunction[data] represents a transformation function that applies geometric and other transformations.

TransformationFunctions

TransformationFunctions is an option for Simplify and FullSimplify which gives the list of functions to apply to try to transform parts of an expression. 

TransformationMatrix

TransformationMatrix[tfun] gives the homogeneous matrix associated with a TransformationFunction object.

TransformedDistribution

TransformedDistribution[expr,xdist] represents the transformed distribution of expr where the random variable x follows the distribution dist.

TransformedDistribution[expr,{x1,x2,…}dist] represents the transformed distribution of expr where {x1,x2,…} follows the multivariate distribution dist.

TransformedDistribution[expr,xproc] represents the transformed distribution where expr contains expressions of the form x[t], referring the value at time t from the random process proc.

TransformedDistribution[expr,{x1dist1,x2dist2 ,…}] represents a transformed distribution where x1, x2, … are independent and follow the distributions dist1, dist2, ….

TransformedField

TransformedField[t,f,{x1,x2,…,xn}->{y1,y2,…,yn}] uses the coordinate transformation t to transform the scalar, vector, or tensor field f from coordinates xi to yi.

TransformedProcess

TransformedProcess[expr,xproc,t] represents the transformed process of expr where the variable x follows the random process proc and t denotes the time.

TransformedProcess[expr,{x1proc1,x2proc2,…},t] represents a transformed process where x1, x2, … are independent and follow the processes proc1, proc2, ….

TransformedRegion

TransformedRegion[reg,f] represents the transformed region {f(p)|p∈reg}, where reg is a region and f is a function.

TransitionDirection

TransitionDirection is an option for PaneSelector that specifies the direction in which a transition moves.

TransitionDuration

TransitionDuration is an option for PaneSelector that specifies the duration in seconds that a transition effect should last.

TransitionEffect

TransitionEffect is an option for PaneSelector that specifies the visual effect used when transitioning between states.

TransitiveClosureGraph

TransitiveClosureGraph[g] gives the transitive closure of the graph g.

TransitiveClosureGraph[{v->w,…}] uses rules v->w to specify the graph g. 

TransitiveReductionGraph

TransitiveReductionGraph[g] gives a transitive reduction of the graph g.

TransitiveReductionGraph[{v->w,…}] uses rules v->w to specify the graph g. 

Translate

Translate[g,{x,y,…}] represents graphics primitives g translated by the vector {x,y,…}. 

Translate[g,{{x1,y1,…},{x2,y2,…}, …}] represents multiple copies of g translated by a collection of vectors.

TranslationOptions

TranslationOptions->{opt1->val1,opt2->val2,…} is an option for Style and Cell that controls how code translations are displayed.

TranslationTransform

TranslationTransform[v] gives a TransformationFunction that represents translation of points by a vector v.

Transliterate

Transliterate["string"] attempts to transliterate string into plain ASCII.

Transliterate["string",script] attempts to transliterate string into the specified writing script script.

Transliterate["string",script1->script2] attempts to transliterate string from script1 to script2.

Transparent

Transparent represents perfect transparency in graphics or style specifications. 

TravelDirections

TravelDirections[{loc1,loc2,…}] generates directions for travel from loc1 to loc2, ….

TravelDirections[{loc1,loc2,…},"prop"] gives the property prop of travel directions.

TravelDirectionsData

TravelDirectionsData[…] represents travel directions generated by TravelDirections.

TravelDistance

TravelDistance[{loc1,loc2,…}] gives the estimated distance for travel from loc1 to loc2, ….

TravelDistanceList

TravelDistanceList[{loc1,loc2,…,locn}] returns the list {TravelDistance[loc1,loc2],…,TravelDistance[locn-1,locn]}.

TravelMethod

TravelMethod is an option for TravelDirections and related functions that specifies the mode of transportation to assume.

TravelTime

TravelTime[{loc1,loc2,…}] gives the estimated time to travel from loc1 to loc2, ….

Tree

Tree[{subtree1,subtree2,…}] represents a tree with a list of child subtrees subtreei.

Tree[<|key1->subtree1,key2->subtree2,…|>] specifies the children as an association with keys keyi.

Tree[data,subtrees] represents a tree containing data in its root, with children given by subtrees.

TreeCases

TreeCases[tree,pattern] gives a list of subtrees of tree with data matching pattern.

TreeCases[tree,pattern,levelspec] gives a list of all subtrees of tree on levels specified by levelspec with data that matches the pattern.

TreeCases[tree,pattern,levelspec,n] gives the first n subtrees in tree with data that matches the pattern.

TreeCases[pattern] represents an operator form of TreeCases that can be applied to a tree.

TreeChildren

TreeChildren[tree] extracts the children of the root of the Tree object tree.

TreeCount

TreeCount[tree,pattern] gives the number of subtrees of tree whose data matches pattern.

TreeCount[tree,pattern,levelspec] gives the total number of subtrees with data matching pattern that appear at the levels in tree specified by levelspec.

TreeCount[pattern] represents an operator form of TreeCount that can be applied to a tree.

TreeData

TreeData[tree] extracts the data in the root of the Tree object tree.

TreeDelete

TreeDelete[tree,pos] deletes the subtree of tree at the position specified by pos.

TreeDelete[tree,{pos1,pos2,…}] deletes subtrees at several positions.

TreeDelete[pos] represents an operator form of TreeDelete that can be applied to a tree.

TreeDepth

TreeDepth[tree] gives the maximum level of tree.

TreeDepth[tree,pattern] gives the maximum level of the subtree with data matching pattern.

TreeElementLabel

TreeElementLabel is an option for Tree and related functions that specifies what labels should be used for subtree elements.

TreeElementStyle

TreeElementStyle is an option for Tree and related functions that specifies what styles should be used for subtree elements.

TreeExpression

TreeExpression[tree] gives an expression from the structure of the Tree object tree.

TreeExpression[tree,struct] gives an expression with data and subtrees of tree interpreted as specified by struct.

TreeExtract

TreeExtract[tree,pos] extracts the subtree of tree at the position specified by pos.

TreeExtract[tree,{pos1,pos2,…}] extracts a list of subtrees of tree.

TreeExtract[tree,pos,h] extracts subtrees of tree, applying h to each subtree.

TreeExtract[pos] represents an operator form of TreeExtract that can be applied to a tree.

TreeForm

TreeForm[expr] displays expr as a tree with different levels at different depths. 

TreeForm[expr,n] displays expr as a tree only down to level n.

TreeGraph

TreeGraph[{v1,v2,…},{u1,u2,…}] yields a tree where ui is the predecessor of vi.

TreeGraph[{e1,e2,…}] yields a tree with edges ej.

TreeGraph[{v1,v2,…},{e1,e2,…}] yields a tree with vertices vi and edges ej.

TreeGraph[{…,wi[vi,…],…},{…,wj[ej,…],…}] yields a tree with vertex and edge properties defined by the symbolic wrappers wk.

TreeGraph[{vi->vj,…}] uses rules vi->vj to specify a tree.

TreeGraphQ

TreeGraphQ[g] yields True if the graph g is a tree and False otherwise.

TreeInsert

TreeInsert[tree,child,pos] inserts child at the position specified by pos in tree.

TreeInsert[tree,child,{pos1,pos2,…}] inserts child at several positions.

TreeInsert[child,pos] represents an operator form of TreeInsert that can be applied to a tree.

TreeLayout

TreeLayout is an option to Tree and related functions that specifies what layout to use.

TreeLeafQ

TreeLeafQ[tree] gives True if tree is a Tree object with no children, and gives False otherwise.

TreeLeaves

TreeLeaves[tree] returns the list of leaves of the tree tree.

TreeLevel

TreeLevel[tree,levelspec] gives a list of all subtrees of tree on levels specified by levelspec.

TreeLevel[tree,levelspec->elem] gives a list of the element elem of subtrees on levels specified by levelspec.

TreeLevel[levelspec] represents an operator form of TreeLevel that can be applied to a tree.

TreeMap

TreeMap[f,tree] applies f to the data of each subtree of tree.

TreeMap[f,tree,levelspec] applies f to the data of subtrees on levels of tree specified by levelspec.

TreeMap[f,tree,levelspec->elems] applies f to the elements elems of subtrees on levels specified by levelspec.

TreeMap[f] represents an operator form of TreeMap that can be applied to a tree.

TreeMapAt

TreeMapAt[f,tree,pos] applies f to the data at the position specified by pos in tree.

TreeMapAt[f,tree,{pos1,pos2,…}] applies f to the data at several positions.

TreeMapAt[f,pos] represents an operator form of TreeMapAt that can be applied to a tree.

TreeOutline

TreeOutline[tree] gives an outline of the data in tree as a nested OpenerView.

TreeOutline[tree,pos] gives an outline of the data in tree initially opened to the subtree at the position specified by pos.

TreeOutline[tree,{pos1,pos2,…}] opens the outline to several positions.

TreePlot

TreePlot[g] generates a tree plot of the graph g.

TreePlot[{e1,e2,…}] generates a tree plot of the graph with edges ej.

TreePlot[{…,w[ei],…}] plots ei with features defined by the symbolic wrapper w.

TreePlot[{vi1->vj1,…}] uses rules vi1->vj1 to specify the graph g.

TreePlot[m] generates a tree plot of the graph represented by the adjacency matrix m.

TreePlot[…,v->pos] places the root v in the plot at position pos.

TreePosition

TreePosition[tree,pattern] gives a list of the positions of subtrees of tree whose data matches pattern.

TreePosition[tree,pattern,levelspec] finds only matches that appear on levels of tree specified by levelspec.

TreePosition[tree,pattern,levelspec,n] gives the positions of the first n matches found.

TreePosition[pattern] represents an operator form of TreePosition that can be applied to a tree.

TreeQ

TreeQ[tree] yields True if tree is a valid Tree object and False otherwise.

TreeReplacePart

TreeReplacePart[tree,pos->new] gives a tree in which the subtree of tree at the position specified by pos is replaced with new.

TreeReplacePart[tree,{pos1->new1,pos2->new2,…}] replaces subtrees at positions specified by posi with newi.

TreeReplacePart[tree,{pos1,pos2,…}->new] replaces all subtrees at positions specified by posi with new.

TreeReplacePart[tree,{{pos1,1,pos1,2,…}->new1,…}] replaces subtrees at positions specified by {posi,1,posi,2,…} with newi.

TreeReplacePart[pos->new] represents an operator form of TreeReplacePart that can be applied to a tree.

TreeRules

TreeRules[tree] returns the rules associated with the Tree object tree.

TreeScan

TreeScan[f,tree] evaluates f applied to the data of each subtree of tree in turn.

TreeScan[f,tree,levelspec] applies f to the data of subtrees on levels of tree specified by levelspec.

TreeScan[f,tree,levelspec->elems] applies f to the elements elems of subtrees on levels specified by levelspec.

TreeScan[f] represents an operator form of TreeScan that can be applied to a tree.

TreeSelect

TreeSelect[tree,crit] picks out all subtrees treei of tree for which crit[treei] is True.

TreeSelect[tree,crit,n] picks out the first n subtrees for which crit[treei] is True.

TreeSelect[tree,crit,levelspec,n] picks out subtrees on levels specified by levelspec.

TreeSelect[crit] represents an operator form of TreeSelect that can be applied to a tree.

TreeSize

TreeSize[tree] gives the number of subtrees of tree.

TreeTraversalOrder

TreeTraversalOrder is an option for TreeMap and related functions that specifies the order to visit subtrees.

TrendStyle

TrendStyle is an option to CandlestickChart, RenkoChart, and other financial charting functions that specifies how to style price trends. 

Triangle

Triangle[{p1,p2,p3}] represents a filled triangle with corner points p1, p2, and p3.

Triangle[{{p11,p12,p13},…}] represents a collection of triangles. 

TriangleCenter

TriangleCenter[tri,type] gives the specified type of center for the triangle tri.

TriangleCenter[tri] gives the centroid of the triangle.

TriangleConstruct

TriangleConstruct[tri,type] gives the specified type of construct for the triangle tri.

TriangleMeasurement

TriangleMeasurement[tri,type] gives the specified type of measurement for the triangle tri.

TriangleWave

TriangleWave[x] gives a triangle wave that varies between -1 and +1 with unit period.

TriangleWave[{min,max},x] gives a triangle wave that varies between min and max with unit period.

TriangularDistribution

TriangularDistribution[{min,max}] represents a symmetric triangular statistical distribution giving values between min and max. 

TriangularDistribution[] represents a symmetric triangular statistical distribution giving values between 0 and 1.

TriangularDistribution[{min,max},c] represents a triangular distribution with mode at c.

TriangulateMesh

TriangulateMesh[mr] generates a triangulation of the mesh region mr.

Trig

Trig is an option for various polynomial manipulation functions that specifies whether trigonometric functions should be treated like polynomial elements.

TrigExpand

TrigExpand[expr] expands out trigonometric functions in expr. 

TrigFactor

TrigFactor[expr] factors trigonometric functions in expr. 

TrigFactorList

TrigFactorList[expr] factors trigonometric functions in expr, yielding a list of lists containing trigonometric monomials and exponents. 

TrigReduce

TrigReduce[expr] rewrites products and powers of trigonometric functions in expr in terms of trigonometric functions with combined arguments. 

TrigToExp

TrigToExp[expr] converts trigonometric functions in expr to exponentials. 

TrimmedMean

TrimmedMean[list,f] gives the mean of the elements in list after dropping a fraction f of the smallest and largest elements.

TrimmedMean[list,{f1,f2}] gives the mean when a fraction f1 of the smallest elements and a fraction f2 of the largest elements are removed.

TrimmedMean[list] gives the 5% trimmed mean TrimmedMean[list,0.05].

TrimmedMean[dist,…] gives the trimmed mean of a univariate distribution dist.

TrimmedVariance

TrimmedVariance[list,f] gives the variance of the elements in list after dropping a fraction f of the smallest and largest elements.

TrimmedVariance[list,{f1,f2}] gives the variance when a fraction f1 of the smallest elements and a fraction f2 of the largest elements are removed.

TrimmedVariance[list] gives the 5% trimmed variance TrimmedVariance[list,0.05].

TrimmedVariance[dist,…] gives the trimmed variance of a univariate distribution dist.

TropicalStormData

TropicalStormData[entity,property] gives the value of the specified property for the tropical storm entity.

TropicalStormData[{entity1,entity2,…},property] gives a list of property values for the specified tropical storm entities.

TropicalStormData[entity,property,annotation] gives the specified annotation associated with the given property.

True

True is the symbol for the Boolean value true. 

TrueQ

TrueQ[expr] yields True if expr is True, and yields False otherwise. 

TruncatedDistribution

TruncatedDistribution[{xmin,xmax},dist] represents the distribution obtained by truncating the values of dist to lie between xmin and xmax.

TruncatedDistribution[{{xmin,xmax},{ymin,ymax},…},dist] represents the distribution obtained by truncating the values of the multivariate distribution dist to lie between xmin and xmax, ymin and ymax, etc.

TruncatedPolyhedron

TruncatedPolyhedron[poly] gives the truncated polyhedron of poly by truncating all vertices. 

TruncatedPolyhedron[poly,l] truncates the polyhedron poly by a length ratio l at its vertices.

TsallisQExponentialDistribution

TsallisQExponentialDistribution[λ,q] represents a Tsallis q-exponential distribution with scale inversely proportional to parameter λ.

TsallisQGaussianDistribution

TsallisQGaussianDistribution[μ,β,q] represents a Tsallis q-Gaussian distribution with mean μ, scale parameter β, and deformation parameter q.

TsallisQGaussianDistribution[q] represents a Tsallis q-Gaussian distribution with mean 0 and scale parameter 1.

TTest

TTest[data] tests whether the mean of data is zero. 

TTest[{data1,data2}] tests whether the means of data1 and data2 are equal.

TTest[dspec,μ0] tests the mean against μ0.

TTest[dspec,μ0,"property"] returns the value of "property".

Tube

Tube[{{x1,y1,z1},{x2,y2,z2},…}] represents a 3D tube around the line joining a sequence of points.

Tube[{pt1,pt2,…},r] represents a tube of radius r.

Tube[{{pt11,pt12,…},{pt21,…},…},…] represents a collection of tubes.

Tube[curve,…] represents a tube around the specified 3D curve.

Tuesday

Tuesday is a day of the week.

TukeyLambdaDistribution

TukeyLambdaDistribution[λ] represents Tukey's lambda distribution with shape parameter λ.

TukeyLambdaDistribution[λ,μ,σ] represents Tukey's lambda distribution with location parameter μ and scale parameter σ.

TukeyLambdaDistribution[{λ1,λ2},μ,{σ1,σ2}] represents the generalized Tukey's lambda distribution with location parameter μ, scale parameters σ1 and σ2, and shape parameters λ1 and λ2.

TukeyWindow

TukeyWindow[x] represents a Tukey window function of x.

TukeyWindow[x,α] uses the parameter α.

TunnelData

TunnelData[entity,property] gives the value of the specified property for the tunnel entity.

TunnelData[{entity1,entity2,…},property] gives a list of property values for the specified tunnel entities.

TunnelData[entity,property,annotation] gives the specified annotation associated with the given property.

TuranGraph

TuranGraph[n,k] gives the k-partite Turán graph with n vertices Tn,k.

TuringMachine

TuringMachine[rule,init,t] generates a list representing the evolution of the Turing machine with the specified rule from initial condition init for t steps. 

TuringMachine[rule,init] gives the result of evolving init for one step. 

TuringMachine[rule] is an operator form of TuringMachine that corresponds to one step of evolution.

TuttePolynomial

TuttePolynomial[g,{x,y}] gives the Tutte polynomial of the graph g.

TuttePolynomial[{v->w,…},…] uses rules v->w to specify the graph g. 

TwoWayRule

x<->y or xy represents a two-way rule expressing exchange or correspondence of x and y.

Typed

Typed[expr,type] represents an expression that should be assumed to be of a specified type for compilation and other purposes.

TypeSpecifier

TypeSpecifier[cons] represents a type.

TypeSpecifier[cons][type1,…] or cons::[type1,…] represents a compound type.

UnateQ

UnateQ[bexpr,{x1,x2,…}] tests whether the Boolean expression bexpr is positive unate in the variables x1, x2, … .

UnateQ[bexpr,{¬x1,¬x2,…}] tests whether the Boolean expression bexpr is negative unate in the variables x1, x2, … .

Uncompress

Uncompress["string"] recovers an expression from a compressed string representation generated by Compress.

Uncompress["string",h] wraps the head h around the expression produced before evaluating it. 

UnconstrainedParameters

UnconstrainedParameters is an option to functions like GeometricScene that specifies what parameters should be treated as unconstrained, so that they can take on any possible value.

Undefined

Undefined is a symbol that represents a quantity with no defined value.

UnderBar

UnderBar[expr] displays with a bar under expr.

Underflow

Underflow[] represents a number too small to represent explicitly on your computer system.

Underlined

Underlined represents an underlined font.

Underoverscript

Underoverscript[x,y,z] is an object that formats as x+y%z. 

Underscript

Underscript[x,y] is an object that formats as x+y. 

UnderseaFeatureData

UnderseaFeatureData[entity,property] gives the value of the specified property for the undersea feature entity.

UnderseaFeatureData[{entity1,entity2,…},property] gives a list of property values for the specified undersea feature entities.

UnderseaFeatureData[entity,property,annotation] gives the specified annotation associated with the given property.

UndirectedGraph

UndirectedGraph[g] gives an undirected graph from the directed graph g.

UndirectedGraph[{v->w,…}] uses rules v->w to specify the graph g. 

UndirectedGraphQ

UndirectedGraphQ[g] yields True if the graph g is an undirected graph and False otherwise.

Unequal

lhs!=rhs or lhs≠rhs returns False if lhs and rhs are identical. 

UnequalTo

UnequalTo[y] is an operator form that yields x≠y when applied to an expression x.

Unevaluated

Unevaluated[expr] represents the unevaluated form of expr when it appears as the argument to a function. 

UniformDistribution

UniformDistribution[{min,max}] represents a continuous uniform statistical distribution giving values between min and max. 

UniformDistribution[] represents a uniform distribution giving values between 0 and 1.

UniformDistribution[{{xmin,xmax},{ymin,ymax},…}] represents a multivariate uniform distribution over the region {{xmin,xmax},{ymin,ymax},…}.

UniformDistribution[n] represents a multivariate uniform distribution over the standard n dimensional unit hypercube. 

UniformGraphDistribution

UniformGraphDistribution[n,m] represents a uniform graph distribution on n-vertex, m-edge graphs.

UniformPolyhedron

UniformPolyhedron["name"] gives the uniform polyhedron with the given name.

UniformPolyhedron[{n,m}] gives the uniform polyhedron with n sides of each face and m faces meeting at each vertex point.

UniformPolyhedron[{r,θ,ϕ},…] rescales the uniform polyhedron by a factor r and rotates by an angle θ with respect to the z axis and angle ϕ with respect to the y axis.

UniformPolyhedron[{x,y,z},{r,θ,ϕ},…] centers the uniform polyhedron at {x,y,z}.

UniformSumDistribution

UniformSumDistribution[n] represents the distribution of a sum of n random variables uniformly distributed from 0 to 1.

UniformSumDistribution[n,{min,max}] represents the distribution of a sum of n random variables uniformly distributed from min to max.

Uninstall

Uninstall[link] terminates an external program started by Install, and removes Wolfram Language definitions set up by it. 

Union

Union[list1,list2,…] gives a sorted list of all the distinct elements that appear in any of the listi. 

Union[list] gives a sorted version of a list, in which all duplicated elements have been dropped. 

UnionedEntityClass

UnionedEntityClass[class1,…] represents an entity class containing all the distinct entities in all the classi.

UnionPlus

UnionPlus[x,y,…] displays as x⊎y⊎….

Unique

Unique[] generates a new symbol, whose name is of the form $nnn. 

Unique[x] generates a new symbol, with a name of the form x$nnn. 

Unique[{x,y,…}] generates a list of new symbols. 

Unique["xxx"] generates a new symbol, with a name of the form xxxnnn. 

UnitaryMatrixQ

UnitaryMatrixQ[m] gives True if m is a unitary matrix, and False otherwise.

UnitConvert

UnitConvert[quantity,targetunit] attempts to convert the specified quantity to the specified targetunit.

UnitConvert[quantity] converts the specified quantity to SI base units.

UnitDimensions

UnitDimensions[unit] returns a list of base dimensions associated with the specified unit.

UnitDimensions[quantity] returns a list of base dimensions associated with the unit of the specified quantity.

Unitize

Unitize[x] gives 0 when x is zero, and 1 when x has any other numerical value.

UnitRootTest

UnitRootTest[data] tests whether data came from an autoregressive time series process with unit root.

UnitRootTest[data,model,"property"] returns the value of "property" for a given model.

UnitSimplify

UnitSimplify[quantity] attempts to simplify the units of the specified quantity.

UnitStep

UnitStep[x] represents the unit step function, equal to 0 for x<0 and 1 for x≥0. 

UnitStep[x1,x2,…] represents the multidimensional unit step function which is 1 only if none of the xi are negative. 

UnitTriangle

UnitTriangle[x] represents the unit triangle function on the interval x≤1 .

UnitTriangle[x1,x2,…] represents the multidimensional unit triangle function on the interval xi≤1.

UnitVector

UnitVector[k] gives the two-dimensional unit vector in the kth direction.

UnitVector[n,k] gives the n-dimensional unit vector in the kth direction.

UnitVectorLayer

UnitVectorLayer[n] represents a net layer that transforms integers between 1 and n into n-dimensional unit vectors. 

UnitVectorLayer[] leaves the n to be inferred from context.

UnityDimensions

UnityDimensions is an option for UnitSimplify that specifies which UnitDimensions should be factored out.

UniverseModelData

UniverseModelData[spec] returns properties of the universe based on the default model at specification defined by the time after the Big Bang, the distance to the comoving object, or the redshift of such an object.

UniverseModelData[spec,model] returns properties of universe model at spec.

UniverseModelData[spec,property] returns the specified property at the time or distance spec.

UniverseModelData[spec,property,model] returns the specified property at the time or distance spec for the universe model.

UniversityData

UniversityData[entity,property] gives the value of the specified property for the university entity.

UniversityData[{entity1,entity2,…},property] gives a list of property values for the specified university entities.

UniversityData[entity,property,annotation] gives the specified annotation associated with the given property.

UnixTime

UnixTime[] gives the total number of seconds since the beginning of January 1, 1970, in the GMT time zone.

UnixTime[{y,m,d,h,m,s}] gives the Unix time specification corresponding to a date list.

UnixTime[date] gives the Unix time specification corresponding to a DateObject.

UnixTime["string"] gives the Unix time specification corresponding to a date string.

UnixTime[{"string",{e1,e2,…}}] takes the date string to contain the elements "ei".

Unprotect

Unprotect[s1,s2,…] removes the attribute Protected for the symbols si.

Unprotect[patt1,patt2,…] unprotects all symbols whose names textually match any of the arbitrary string patterns patti.

Unprotect[{spec1,spec2,…}] unprotects any symbols that are equal to or whose names match any of the speci.

UnregisterExternalEvaluator

UnregisterExternalEvaluator[sys,evaluator] unregisters the external evaluator referenced by evaluator for system sys so that it is not used by ExternalEvaluate and related functions.

UnsameQ

lhs=!=rhs yields True if the expression lhs is not identical to rhs, and yields False otherwise. 

Unset

lhs=. removes any rules defined for lhs. 

UnsetShared

UnsetShared[s1,s2,…] stops the sharing of the variables or functions si among parallel kernels.

UnsetShared[patt] stops the sharing of all variables and functions whose names match the string pattern patt.

UpArrow

UpArrow[x,y,…] displays as x↑y↑….

UpArrowBar

UpArrowBar[x,y,…] displays as x⤒y⤒….

UpArrowDownArrow

UpArrowDownArrow[x,y,…] displays as x⇅y⇅….

Update

Update[symbol] tells the Wolfram Language that hidden changes have been made that could affect values associated with a symbol. 

Update[] specifies that the value of any symbol could be affected. 

UpdatePacletSites

UpdatePacletSites is an option to PacletInstall and PacletInstallSubmit that specifies whether to first update the local cache of information about available paclets.

UpdateSearchIndex

UpdateSearchIndex[obj] updates the given search index object.

UpdateSearchIndex["name"] updates the search index with the specified name in the SearchIndices[] list.

UpDownArrow

UpDownArrow[x,y,…] displays as x↕y↕….

UpEquilibrium

UpEquilibrium[x,y,…] displays as x⥮y⥮….

UpperCaseQ

UpperCaseQ[string] yields True if all the characters in the string are uppercase letters, and yields False otherwise. 

UpperLeftArrow

UpperLeftArrow[x,y,…] displays as x↖y↖….

UpperRightArrow

UpperRightArrow[x,y,…] displays as x↗y↗….

Upsample

Upsample[array,n] returns an upsampled version of the array by inserting n-1 zeros between array elements.

Upsample[array,n,offset] shifts array so that its first element moves to the position offset in the resulting array.

Upsample[array,n,offset,val] inserts n-1 elements of value val between array elements.

Upsample[image,…] upsamples an image.

UpSet

lhs^=rhs assigns rhs to be the value of lhs, and associates the assignment with symbols that occur at level one in lhs. 

UpSetDelayed

lhs^:=rhs assigns rhs to be the delayed value of lhs, and associates the assignment with symbols that occur at level one in lhs. 

UpTee

UpTee[x,y] displays as x⊥y.

UpTeeArrow

UpTeeArrow[x,y,…] displays as x↥y↥….

UpTo

UpTo[n] is a symbolic specification that represents up to n objects or positions. If n objects or positions are available, all are used. If fewer are available, only those available are used.

UpValues

UpValues[f] gives a list of transformation rules corresponding to all upvalues (values for g[…,f[…],…]) defined for the symbol f. 

UpValues["symbol"] gives a list of transformation rules corresponding to all upvalues defined for the symbol named "symbol" if it exists.

URL

URL["url"] is a symbolic representation of a URL.

URLBuild

URLBuild["path",{param1->val1,param2->val2,…}] builds a URL with the specified path and query parameters and values parami and vali.

URLBuild[{path1,path2,…}] builds a URL from the path components pathi.

URLBuild[path,params] builds a URL from a specification of a path and query parameters.

URLBuild[assoc] builds a URL from an association of components.

URLBuild[assoc,params] builds a URL from an association of components, plus query parameters and values.

URLDecode

URLDecode["string"] decodes a URL-style percent-encoded string.

URLDispatcher

URLDispatcher[{patt1content1,patt2content2,…}] represents a dispatcher for deployed URLs that specifies that URLs with relative paths matching the string patterns patti should give content represented by contenti.

URLDownload

URLDownload[url] downloads the content of the specified URL to a local temporary file.

URLDownload[{url1,url2,…}] downloads the contents of the specified URLs to files in a local temporary directory.

URLDownload[url,file] downloads to a specified file.

URLDownload[{url1,url2,…},dir] downloads to a specified directory.

URLDownload[HTTPRequest[…],…] downloads the result of the specified HTTP request.

URLDownload[{req1,req2,…},…] downloads the results of the list of HTTP requests.

URLDownload[req,loc,"elem"] returns only the element elem from the response.

URLDownload[req,loc,"elem"] returns only the element elem from the response.

URLDownload[req,loc,{elem1,elem2,…}] returns an association of the values of the elements elemi.

URLDownloadSubmit

URLDownloadSubmit[url, file] submits the specified URL to be downloaded asynchronously to the file given.

URLDownloadSubmit[url,file,{param1->val1,param2->val2,…}] submits the specified URL, adding elements with names parami and values vali. 

URLDownloadSubmit[obj,…] submits the cloud object obj.

URLDownloadSubmit[HTTPRequest[…],…] submits the specified HTTP request.

URLEncode

URLEncode["string"] converts "string" into a URL-style, percent-encoded ASCII string. 

URLExecute

URLExecute[url] executes the specified URL, importing whatever result is generated.

URLExecute[url,{param1->val1,param2->val2,…}] executes the specified URL, adding elements with names parami and values vali.

URLExecute[url,params,format] imports the result using the specified format.

URLExecute[CloudObject[…],…] executes a cloud object with current authentication settings. 

URLExecute[HTTPRequest[…],…] executes the specified HTTP request.

URLExpand

URLExpand["url"] expands a shortened "url".

URLFetch

URLFetch[url] returns the contents of a URL as a string.

URLFetch[url,elements] returns the specified elements from a URL.

URLFetchAsynchronous

URLFetchAsynchronous[url,func] performs a connection in the background, calling func when an event is raised.

URLParse

URLParse["url"] takes a well-formed URL and gives an association whose values correspond to the components of the URL.

URLParse["url","component"] returns only the specified component.

URLParse["url",{component1,component2,…}] returns only the specified component list.

URLQueryDecode

URLQueryDecode["string"] decodes a URL-style query string into a list of key-value rules. 

URLQueryEncode

URLQueryEncode[<|key1->val1,key2->val2,…|>] creates a URL-style query string from an association of keys and values. 

URLQueryEncode[{param1->val1,param2->val1,…}] creates a query string from a list of rules.

URLRead

URLRead[url] sends a request to a URL and reads back the response, returning it as a response object.

URLRead[assoc] sends a request to a URL built from an association of components and metadata elements.

URLRead[HTTPRequest[…]] sends a request specified by a symbolic HTTPRequest object.

URLRead[req,"elem"] returns only the element elem from the response.

URLRead[req,{elem1,elem2,…}] returns an association of the values of the elements elemi.

URLRead[{req1,req2,…},…] sends the requests reqi in parallel, giving a list of the results obtained.

URLResponseTime

URLResponseTime[url] gives the total number of seconds to request one byte from the specified URL.

URLResponseTime[url,prop] gives the specified timing.

URLSave

URLSave["url"] saves the content of the URL to a file in $TemporaryDirectory.

URLSave["url","file"] saves the content of the URL to a file.

URLSave["url","file",elements] returns the specified elements from a URL.

URLSaveAsynchronous

URLSaveAsynchronous["url","file",func] performs a download to "file" in the background, calling func when an event is raised.

URLShorten

URLShorten["url"] creates a shortened URL that redirects to "url".

URLShorten[CloudObject[…]] creates a shortened URL that redirects to the URL for the specified cloud object.

URLSubmit

URLSubmit[url] submits the specified URL to be executed asynchronously.

URLSubmit[url,{param1->val1,param2->val2,…}] submits the specified URL, adding elements with names parami and values vali. 

URLSubmit[obj,…] submits the cloud object obj.

URLSubmit[HTTPRequest[…],…] submits the specified HTTP request.

UseEmbeddedLibrary

UseEmbeddedLibrary is an option of FunctionCompile that embeds a shared library in a CompiledCodeFunction.

Using

Using is an option to Roots that specifies any subsidiary equations that are to be used.

UtilityFunction

UtilityFunction is an option for Predict, Classify, and related functions that specifies the utility value to assign to each possible pairing of actual and predicted values.

V2Get

V2Get[name] reads in a file written by the V2.x versions.

ValenceFilling

ValenceFilling is an option for Molecule that specifies whether to fill open valences with hydrogen atoms.

ValidationLength

ValidationLength is an option to FindSequenceFunction and related functions that specifies the number of elements in the input sequence that should be used to validate a potential representation found.

ValidationSet

ValidationSet is an option for Predict, Classify, NetTrain, and related functions that specifies the validation set to be used during the training phase.

ValueDimensions

ValueDimensions is an option to TemporalData, TimeSeries, and EventSeries that specifies the dimension of the value space. 

ValueForm

ValueForm is an internal symbol.

ValuePreprocessingFunction

ValuePreprocessingFunction is an option for functions such as PersistentSymbol and InitializationValue that specifies a function to apply to a new value that is being assigned.

ValueQ

ValueQ[expr] gives True if a value has been defined for expr, and gives False otherwise. 

Values

Values[<|key1->val1,key2->val2,…|>] gives a list of the values vali in an association.

Values[{key1->val1,key2->val2,…}] gives a list of the vali in a list of rules.

Values[expr,h] gives a list of values in expr, wrapping each of them with head h before evaluation. 

Variables

Variables[poly] gives a list of all independent variables in a polynomial. 

Variance

Variance[data] gives the variance estimate of the elements in data. 

Variance[dist] gives the variance of the distribution dist.

VarianceEquivalenceTest

VarianceEquivalenceTest[{data1,data2,…}] tests whether the variances of the datai are equal. 

VarianceEquivalenceTest[{data1,…},"property"] returns the value of "property".

VarianceEstimatorFunction

VarianceEstimatorFunction is an option for LinearModelFit and NonlinearModelFit which specifies the variance estimator to use.

VarianceGammaDistribution

VarianceGammaDistribution[λ,α,β,μ] represents a variance‐gamma distribution with location parameter μ, skewness parameter β, and shape parameters λ and α.

VariogramFunction

VariogramFunction is an option to SpatialEstimate that specifies the local variation model to use. 

VariogramModel

VariogramModel["model",{params}] represents the function for the variogram model specified by "model".

VectorAngle

VectorAngle[u,v] gives the angle between the vectors u and v.

VectorAround

VectorAround[{x1,x2,…},{δ1,δ2,…}] represents a vector of uncorrelated approximate numbers or quantities with values xi and uncertainties δi.

VectorAround[{x1,x2,…},{{Δ11,Δ12,…},{Δ12,Δ22,…},…}] represents a vector of approximate numbers or quantities with values xi and covariance matrix Δ.

VectorAround[{x1,x2},{{δ1,δ2},ρ}] represents a pair of approximate numbers or quantities with uncertainties δ1, δ2 and correlation factor ρ.

VectorAround[{x1,x2,…},{{δ1,δ2,…},{{1,R12,…},{R12,1,…},…}}] represents a vector of approximate numbers or quantities with uncertainties δi and correlation matrix R.

VectorAspectRatio

VectorAspectRatio is an option setting for VectorPlot and related functions that determines the relative width and length of the arrow markers in the plot.

VectorColorFunction

VectorColorFunction is an option for VectorPlot and related functions that specifies a function to apply to determine colors of field vectors drawn. 

VectorColorFunctionScaling

VectorColorFunctionScaling is an option for graphics functions which specifies whether arguments supplied to a vector color function should be scaled to lie between 0 and 1. 

VectorDensityPlot

VectorDensityPlot[{{vx,vy},r},{x,xmin,xmax},{y,ymin,ymax}] generates a vector plot of the vector field {vx,vy} as a function of x and y, superimposed on a density plot of the scalar field r. 

VectorDensityPlot[{vx,vy},{x,xmin,xmax},{y,ymin,ymax}] takes the scalar field to be the norm of the vector field.

VectorDensityPlot[{{vx,vy},{wx,wy},…,r},{x,xmin,xmax},{y,ymin,ymax}] plots several vector fields. 

VectorDensityPlot[…,{x,y}∈reg] takes the variables {x,y} to be in the geometric region reg. 

VectorDisplacementPlot

VectorDisplacementPlot[{vx,vy},{x,xmin,xmax},{y,ymin,ymax}] generates a displacement plot for the vector field {vx,vy} as a function of x and y.

VectorDisplacementPlot[{vx,vy},{x,y}∈reg] plots the displacement over the geometric region reg.

VectorDisplacementPlot[{{vx,vy},s},…] uses the scalar field s to style the displacement.

VectorDisplacementPlot3D

VectorDisplacementPlot3D[{vx,vy,vz},{x,xmin,xmax},{y,ymin,ymax},{z,zmin,zmax}] generates a displacement plot of the vector field {vx,vy,vz} as a function of x, y and z.

VectorDisplacementPlot3D[{vx,vy,vz},{x,y,z}∈reg] plots the displacement over the geometric region reg.

VectorDisplacementPlot3D[{{vx,vy,vz},s},…] uses the scalar field s to style the displacement.

VectorGreater

xy or VectorGreater[{x,y}] yields True for vectors of length n if xi>yi for all components 1≤i≤n.

xκy or VectorGreater[{x,y},κ] yields True for x and y if x-y∈interior(κ), where κ is a proper convex cone.

VectorGreaterEqual

xy or VectorGreaterEqual[{x,y}] yields True for vectors of length n if xi≥yi for all components 1≤i≤n.

xκy or VectorGreaterEqual[{x,y},κ] yields True for x and y if x-y∈κ, where κ is a proper convex cone.

VectorLess

xy or VectorLess[{x,y}] yields True for vectors of length n if xi<yi for all components 1≤i≤n.

xκy or VectorLess[{x,y},κ] yields True for x and y if y-x∈interior(κ), where κ is a proper convex cone.

VectorLessEqual

xy or VectorLessEqual[{x,y}] yields True for vectors of length n if xi≤yi for all components 1≤i≤n.

xκy or VectorLessEqual[{x,y},κ] yields True for x and y if y-x∈κ, where κ is a proper convex cone.

VectorMarkers

VectorMarkers is an option for graphics functions like VectorPlot, ListVectorPlot and related functions that specifies what markers to draw at the field points plotted. 

VectorPlot

VectorPlot[{vx,vy},{x,xmin,xmax},{y,ymin,ymax}] generates a vector plot of the vector field {vx,vy} as a function of x and y. 

VectorPlot[{{vx,vy},{wx,wy},…},{x,xmin,xmax},{y,ymin,ymax}] plots several vector fields. 

VectorPlot[…,{x,y}∈reg] takes the variables {x,y} to be in the geometric region reg. 

VectorPlot3D

VectorPlot3D[{vx,vy,vz},{x,xmin,xmax},{y,ymin,ymax},{z,zmin,zmax}] generates a 3D vector plot of the vector field {vx,vy,vz} as a function of x, y, and z.

VectorPlot3D[{field1,field2,…},{x,xmin,xmax},{y,ymin,ymax},{z,zmin,zmax}] plots several vector fields.

VectorPlot3D[…,{x,y,z}∈reg] takes the variables {x,y,z} to be in the geometric region reg. 

VectorPoints

VectorPoints is an option to VectorPlot, ListVectorPlot, and related functions that determines where to draw arrows.

VectorQ

VectorQ[expr] gives True if expr is a list or a one‐dimensional SparseArray object, none of whose elements are themselves lists, and gives False otherwise. 

VectorQ[expr,test] gives True only if test yields True when applied to each of the elements in expr. 

VectorRange

VectorRange is an option for VectorPlot and related functions that specifies the range of vector magnitudes to include in a plot.

Vectors

Vectors[d] represents the domain of vectors of dimension d.

Vectors[d,dom] represents the domain of vectors of dimension d, with components in the domain dom.

VectorScale

VectorScale is an option to VectorPlot, ListVectorPlot, and related functions that determines the length and arrowhead size of field vectors that are drawn. 

VectorScaling

VectorScaling is an option for VectorPlot and related functions that determines how the magnitudes of vectors are scaled for visualization.

VectorSizes

VectorSizes is an option for VectorPlot and related functions that specifies the range of sizes used for arrows.

VectorStyle

VectorStyle is an option to VectorPlot, ListVectorPlot, and related functions that determines the style to use for drawing field vectors.

Vee

Vee[x,y,…] displays as x⋁y⋁….

Verbatim

Verbatim[expr] represents expr in pattern matching, requiring that expr be matched exactly as it appears, with no substitutions for blanks or other transformations. 

VerificationTest

VerificationTest[input] runs a verification test to determine whether input evaluates to True.

VerificationTest[input,expected] tests whether input evaluates to expected, without issuing messages.

VerificationTest[input,expected,messages] tests whether input evaluates to expected, generating the list of message names messages.

VerifyConvergence

VerifyConvergence is an option to Sum, NSum, and similar functions that specifies whether convergence checking should be done.

VerifyDerivedKey

VerifyDerivedKey[key,password] verifies that password matches the password used to generate the derived key.

VerifyDigitalSignature

VerifyDigitalSignature[{expr,sig},key] verifies the digital signature sig for expr using the specified public key.

VerifyDigitalSignature[{{expr1,sig1},{expr2,sig2},…},key] verifies the digital signatures sigi for each of the expri, all using the specified public key.

VerifyDigitalSignature[key] is an operator form of VerifyDigitalSignature, suitable for application to {expr,sig} or a list of such pairs.

VerifyFileSignature

VerifyFileSignature[{"file",sig},key] verifies the digital signature sig for file using the specified public key.

VerifyFileSignature[{"file",range,sig},key] verifies the digital signature sig for the specified range of bytes in the file.

VerifyFileSignature[{{file1,range1,sig1},{file2,range2,sig2},…},key] verifies the digital signatures sigi for each of rangei of bytes in the filei, all using the specified public key.

VerifyFileSignature[key] represents an operator form of VerifyFileSignature that can be applied to files.

VerifyInterpretation

VerifyInterpretation is an option for TextCases, TextPosition and TextContents that verifies that results can be interpreted using Interpreter and related functions and drops those that cannot. 

VerifySecurityCertificates

VerifySecurityCertificates is an option for URLRead and related functions that specifies whether to verify security certificates when making an HTTPS connection.

VerifySolutions

VerifySolutions is an option to Solve and related functions that controls whether to verify solutions. 

VerifyTestAssumptions

VerifyTestAssumptions is an option to LocationTest and similar functions that controls which assumptions to verify through diagnostic tests.

VertexAdd

VertexAdd[g,v] makes a graph by adding the vertex v to the graph g.

VertexAdd[g,{v1,v2,…}] adds a collection of vertices to g.

VertexAdd[{v->w,…},…] uses rules v->w to specify the graph g. 

VertexCapacity

VertexCapacity is an option and annotation for Graph and related functions that specifies a vertex capacity.

VertexChromaticNumber

VertexChromaticNumber[g] gives the chromatic number for the vertices of the graph g.

VertexColors

VertexColors is an option for graphics primitives which specifies the colors to assign to vertices.

VertexComponent

VertexComponent[g,{v1,v2,…}] gives the vertices in the graph g that have a path to at least one of v1, v2, … .

VertexComponent[g,{v1,v2,…},k] gives the vertices with a path to at least one of v1, v2, … of at most length k.

VertexComponent[g,{v1,v2,…},{k}] gives the vertices at length exactly k.

VertexComponent[{v->w,…},…] uses rules v->w to specify the graph g.

VertexConnectivity

VertexConnectivity[g] gives the vertex connectivity of the graph g.

VertexConnectivity[g,s,t] gives the s-t vertex connectivity of the graph g.

VertexConnectivity[{v->w,…},…] uses rules v->w to specify the graph g.

VertexContract

VertexContract[g,{v1,v2,…}] contracts a collection of vertices v1, v2, … into a single vertex of the graph g.

VertexContract[g,{{v1,v2,…},…}] contracts several collections of vertices. 

VertexContract[{v->w,…},…] uses rules v->w to specify the graph g.

VertexCoordinateRules

VertexCoordinateRules is an option for GraphPlot and related functions which specifies rules for determining the coordinates at which vertices should be placed.

VertexCoordinates

VertexCoordinates is an option to Graph and related functions that specifies the coordinates to use to place the center of vertices.

VertexCorrelationSimilarity

VertexCorrelationSimilarity[g,u,v] gives the correlation similarity between vertices u and v of the graph g.

VertexCorrelationSimilarity[{v->w,…},…] uses rules v->w to specify the graph g.

VertexCosineSimilarity

VertexCosineSimilarity[g,u,v] gives the cosine similarity between vertices u and v of the graph g.

VertexCosineSimilarity[{v->w,…},…] uses rules v->w to specify the graph g.

VertexCount

VertexCount[g] gives a count of the number of vertices in the graph g.

VertexCount[g,patt] gives a count of the number of vertices that match the pattern patt.

VertexCount[{v->w,…},…] uses rules v->w to specify the graph g.

VertexCoverQ

VertexCoverQ[g,vlist] yields True if the vertex list vlist is a vertex cover of the graph g, and False otherwise.

VertexDataCoordinates

VertexDataCoordinates is an option to Raster3D that determines how to map data to the displayed range.

VertexDegree

VertexDegree[g] gives the list of vertex degrees for all vertices in the graph g.

VertexDegree[g,v] gives the vertex degree for the vertex v.

VertexDegree[{v->w,…},…] uses rules v->w to specify the graph g.

VertexDelete

VertexDelete[g,v] makes a graph by deleting the vertex ν and all edges connected to v from the graph g.

VertexDelete[g,{v1,v2,…}] deletes a collection of vertices from g.

VertexDelete[g,patt] deletes all vertices that match the pattern patt.

VertexDelete[{v->w,…},…] uses rules v->w to specify the graph g.

VertexDiceSimilarity

VertexDiceSimilarity[g,u,v] gives the Dice similarity between vertices u and v of the graph g.

VertexDiceSimilarity[{v->w,…},…] uses rules v->w to specify the graph g.

VertexEccentricity

VertexEccentricity[g,s] gives the length of the longest shortest path from the source s to every other vertex in the graph g.

VertexEccentricity[{v->w,…},…] uses rules v->w to specify the graph g. 

VertexInComponent

VertexInComponent[g,{v1,v2,…},k] gives the vertices with a directed path to at least one of v1, v2, … of at most length k.

VertexInComponent[g,{v1,v2,…},{k}] gives the vertices at length exactly k.

VertexInComponent[{v->w,…},…] uses rules v->w to specify the graph g.

VertexInComponentGraph

VertexInComponentGraph[g,{v1,v2,…}] gives the subgraph of the graph g generated by the vertices that have a directed path to at least one of v1,v2,….

VertexInComponentGraph[g,{v1,v2,…},k] gives the subgraph of g generated by vertices with a directed path of at most length k to at least one of v1,v2,….

VertexInComponentGraph[g,{v1,v2,…},{k}] gives the subgraph of g generated by vertices of length exactly k.

VertexInComponentGraph[{v->w,…},…] uses rules v->w to specify the graph g.

VertexInDegree

VertexInDegree[g] gives the list of vertex in-degrees for all vertices in the graph g.

VertexInDegree[g,v] gives the vertex in-degree for the vertex v.

VertexInDegree[{v->w,…},…] uses rules v->w to specify the graph g.

VertexIndex

VertexIndex[g,v] gives the integer index for the vertex v in the graph g.

VertexIndex[{v->w,…},…] uses rules v->w to specify the graph g.

VertexJaccardSimilarity

VertexJaccardSimilarity[g,u,v] gives the Jaccard similarity between vertices u and v of the graph g.

VertexJaccardSimilarity[{v->w,…},…] uses rules v->w to specify the graph g. 

VertexLabeling

VertexLabeling is an option for GraphPlot and related functions which specifies whether labeling should be included by default for vertices in graphs.

VertexLabels

VertexLabels is an option and annotation for Graph and related functions that specifies what labels and label positions should be used for vertices.

VertexLabelStyle

VertexLabelStyle is an option and property for Graph and related functions that specifies the style to use for vertex labels.

VertexList

VertexList[g] gives the list of vertices for the graph g.

VertexList[g,patt] gives a list of vertices that match the pattern patt.

VertexList[{v->w,…},…] uses rules v->w to specify the graph g. 

VertexNormals

VertexNormals is an option for graphics primitives which specifies the normal directions to assign to 3D vertices.

VertexOutComponent

VertexOutComponent[g,{v1,v2,…}] gives the vertices in the graph g that have a directed path from at least one of v1, v2, ….

VertexOutComponent[g,{v1,v2,…},k] gives the vertices with a directed path from at least one of v1, v2, … of at most length k.

VertexOutComponent[g,{v1,v2,…},{k}] gives the vertices at length exactly k.

VertexOutComponent[{v->w,…},…] uses rules v->w to specify the graph g. 

VertexOutComponentGraph

VertexOutComponentGraph[g,{v1,v2,…}] gives the subgraph of the graph g generated by the vertices that have a directed path from at least one of v1,v2,….

VertexOutComponentGraph[g,{v1,v2,…},k] gives the subgraph of g generated by vertices with a directed path of at most length k from at least one of v1,v2,….

VertexOutComponentGraph[g,{v1,v2,…},{k}] gives the subgraph of g generated by vertices of length exactly k.

VertexOutComponentGraph[{v->w,…},…] uses rules v->w to specify the graph g.

VertexOutDegree

VertexOutDegree[g] gives the list of vertex out-degrees for all vertices in the graph g.

VertexOutDegree[g,v] gives the vertex out-degree for the vertex v.

VertexOutDegree[{v->w,…},…] uses rules v->w to specify the graph g. 

VertexQ

VertexQ[g,v] yields True if v is a vertex in the graph g and False otherwise.

VertexRenderingFunction

VertexRenderingFunction is an option for GraphPlot and related functions that gives a function to generate the graphics primitives to use in rendering each vertex.

VertexReplace

VertexReplace[g,{v1->w1,v2->w2,…}] replaces each vertex vi in the graph g by wi.

VertexReplace[{v->w,…},…] uses rules v->w to specify the graph g. 

VertexShape

VertexShape is an option and property for Graph and related functions that specifies the graphics used for vertices.

VertexShapeFunction

VertexShapeFunction is an option and annotation for Graph and related functions that specifies a function to use to generate primitives for rendering each vertex. 

VertexSize

VertexSize is an option and property for Graph and related functions that specifies the size used for vertices. 

VertexStyle

VertexStyle is an option and annotation for Graph and related functions that specifies what style to use for vertices. 

VertexTextureCoordinates

VertexTextureCoordinates is an option for graphics primitives that specifies the texture coordinates to assign to vertices.

VertexTransitiveGraphQ

VertexTransitiveGraphQ[g] yields True if the graph g is a vertex–transitive graph and False otherwise.

VertexWeight

VertexWeight is an option and annotation for Graph and related functions that specifies a vertex weight.

VertexWeightedGraphQ

VertexWeightedGraphQ[g] yields True if the graph g is a vertex-weighted graph, and False otherwise.

VerticalBar

VerticalBar[x,y,…] displays as xy….

VerticalTilde

VerticalTilde[x,y,…] displays as x≀y≀….

Video

Video[file] represents video stored in the given file.

Video[url] represents video stored in the given URL.

VideoCombine

VideoCombine[{obj1,obj2,…}] creates a multi-track video by combining all audio, video and subtitle tracks in all obji.

VideoDelete

VideoDelete[video,t] deletes the first t seconds of video.

VideoDelete[video,-t] deletes the last t seconds of video.

VideoDelete[video,{t1,t2}] deletes from time t1 to time t2, returning the remaining video as a single Video object.

VideoDelete[video,{{t11,t12},…}] deletes multiple time intervals.

VideoEncoding

VideoEncoding is an option for Export and other functions that specifies the video encoding to use when creating a video file.

VideoExtractFrames

VideoExtractFrames[video,t] extracts a frame at time t from video.

VideoExtractFrames[video,tspec] extracts video frames at time specification tspec.

VideoFrameList

VideoFrameList[video,n] gives a list of n images extracted from video.

VideoFrameList[video,spec] gives a list of frames extracted based on spec.

VideoFrameMap

VideoFrameMap[f,video] applies f to each frame of the Video object video, returning a new Video object.

VideoFrameMap[f,video,n] applies f to overlapping partitions of n video frames.

VideoFrameMap[f,video,n,d] applies f to partitions with offset d.

VideoFrameMap[f,{video1,video2,…},…] applies f to a list of inputs extracted from each videoi.

VideoGenerator

VideoGenerator[imagespec] generates a video with frames generated from imagespec.

VideoGenerator[<|"Image"->imagespec,"Audio"->audiospec|>] returns a video with audio data generated from audioexpr.

VideoGenerator[…,dur] generates a video of duration dur.

VideoInsert

VideoInsert[video,t->new] inserts the video new at time t.

VideoInsert[video,{t1,t2,…}->new] inserts the same video at multiple positions.

VideoInsert[video,{t1->new1,…}] inserts multiple videos at different positions.

VideoIntervals

VideoIntervals[video,crit] returns time intervals of video for which the criterion crit is satisfied.

VideoIntervals[video,crit,n] evaluates criterion crit on partitions of n video frames.

VideoIntervals[video,crit,n,d] evaluates crit on partitions with offset d.

VideoIntervals[{video1,video2,…},crit,…] applies crit to a list of inputs extracted from each videoi.

VideoJoin

VideoJoin[video1,video2,…] concatenates all videoi and returns a video object.

VideoMap

VideoMap[f,video] applies f to partial video and audio data corresponding to one frame of video, returning a new video.

VideoMap[f,video,n] applies f to data corresponding to overlapping partitions of n video frames.

VideoMap[f,video,n,d] applies f to partitions with offset d.

VideoMap[f,{video1,video2,…},…] applies f to a list of inputs extracted from each videoi.

VideoMapList

VideoMapList[f,video] applies f to a chunk of data corresponding to one frame from the Video object video, returning a list of results.

VideoMapList[f,video,n] applies f to overlapping partitions corresponding to n video frames.

VideoMapList[f,video,n,d] applies f to partitions with offset d.

VideoMapList[f,{video1,video2,…},…] applies f to a list of inputs extracted from each videoi.

VideoMapTimeSeries

VideoMapTimeSeries[f,video] applies f to each frame of the Video object video, returning a time series.

VideoMapTimeSeries[f,video,n] applies f to overlapping partitions of n video frames.

VideoMapTimeSeries[f,video,n,d] applies f to partitions with offset d.

VideoMapTimeSeries[f,{video1,video2,…},…] applies f to a list of inputs extracted from each videoi.

VideoPause

VideoPause[] pauses the playback of all VideoStream objects.

VideoPause[vstream] pauses the playback of the VideoStream object vstream.

VideoPlay

VideoPlay[video] returns a new VideoStream object from video and starts the playback.

VideoPlay[vstream] starts playing a VideoStream object vstream.

VideoQ

VideoQ[video] yields True if video has the form of a valid Video object, and False otherwise.

VideoRecord

VideoRecord[source] creates a VideoStream object and records from source.

VideoRecord[vstream] starts recording a VideoStream object vstream that is connected to an imaging device, a screen or a notebook.

VideoReplace

VideoReplace[video,{t1,t2}->new] replaces the video between t1 and t2 with the new video new.

VideoReplace[video,{{t11,t12},…}->new] replaces multiple intervals with the same video new.

VideoReplace[video,{{t11,t12}->new1,…}] replaces multiple intervals.

VideoReplace[video,…,durfitting] uses the specified durfitting method to replace an interval of a different duration.

VideoSplit

VideoSplit[video,t] splits video at time t.

VideoSplit[video,{t1,t2,…}] splits video at times ti.

VideoStop

VideoStop[] stops the playback of all VideoStream objects.

VideoStop[vstream] stops the playback of the VideoStream object vstream.

VideoStream

VideoStream[source] creates a new VideoStream object from source.

VideoStream[id] is an object that represents a unique video stream.

VideoStreams

VideoStreams[] returns all existing video streams.

VideoTimeStretch

VideoTimeStretch[video,spec] applies time stretching to video using the specified spec.

VideoTrackSelection

VideoTrackSelection is an option that specifies the video tracks of interest.

VideoTranscode

VideoTranscode[video,"format"] converts video to the specified format.

VideoTranscode[video,service] converts video to the specification recommended by the specified service.

VideoTranscode[{v1,v2,…},…] converts all vi videos to have conforming properties with respect to the given specification.

VideoTrim

VideoTrim[video,t] returns the first t seconds of video.

VideoTrim[video,-t] returns the last t seconds of video.

VideoTrim[video,{t1,t2}] returns video starting at time t1 and ending at time t2 of video.

VideoTrim[video,{{t11,t12},…}] returns a list of video objects for all given intervals {ti1,ti2}.

ViewAngle

ViewAngle is an option for Graphics3D and related functions that gives the opening angle for a simulated camera used to view the three-dimensional scene. 

ViewCenter

ViewCenter is an option for Graphics3D and related functions which gives the scaled coordinates of the point which should appear at the center of the final image. 

ViewMatrix

ViewMatrix is an option for Graphics3D and related functions that can be used to specify a pair of explicit homogeneous transformation and projection matrices for 3D coordinates.

ViewPoint

ViewPoint is an option for Graphics3D and related functions which gives the point in space from which three‐dimensional objects are to be viewed. 

ViewProjection

ViewProjection is an option for three-dimensional graphics that specifies the projection to use for the graphic.

ViewRange

ViewRange is an option for Graphics3D and related functions which specifies the range of distances from the view point to be included in displaying a three-dimensional scene. 

ViewVector

ViewVector is an option for Graphics3D and related functions which specifies the position and direction of a simulated camera used to view three-dimensional objects. 

ViewVertical

ViewVertical is an option for Graphics3D and related functions which specifies what direction in scaled coordinates should be vertical in the final image. 

VoiceStyleData

VoiceStyleData[] gives the list of available voices for speech synthesis.

VoiceStyleData[voice] returns all properties for the specified voice.

VoiceStyleData[voice,prop] returns the specified property prop for voice.

VoigtDistribution

VoigtDistribution[δ,σ] represents Voigt distribution with parameters δ and σ.

VolcanoData

VolcanoData[entity,property] gives the value of the specified property for the volcano entity.

VolcanoData[{entity1,entity2,…},property] gives a list of property values for the specified volcano entities.

VolcanoData[entity,property,annotation] gives the specified annotation associated with the given property.

Volume

Volume[reg] gives the volume of the three-dimensional region reg.

Volume[{x1,…,xn},{s,smin,smax},{t,tmin,tmax},{u,umin,umax}] gives the volume of the parametrized region whose Cartesian coordinates xi are functions of s, t, u.

Volume[{x1,…,xn},{s,smin,smax},{t,tmin,tmax},{u,umin,umax},chart] interprets the xi as coordinates in the specified coordinate chart.

VonMisesDistribution

VonMisesDistribution[μ,κ] represents a von Mises distribution with mean μ and concentration κ.

VoronoiMesh

VoronoiMesh[{p1,…,pn}] gives a MeshRegion representing the Voronoi mesh from the points p1, p2, ….

VoronoiMesh[{p1,…,pn},{{xmin,xmax},…}] clips the mesh to the bounds [xmin,xmax]×⋯.

WaitAll

WaitAll[expr] waits for all concurrent evaluations represented by EvaluationObject expressions in expr to finish, then returns the resulting expression obtained.

WaitAsynchronousTask

WaitAsynchronousTask[task] waits for task to complete.

WaitNext

WaitNext[{eid1,eid2,…}] waits until the first evaluation represented by any of the eidi finishes, then returns its result, the corresponding eidi, and the list of remaining eidk. 

WaitNext[{eid1,eid2,…},h] wraps the head h around the result before returning it.

WakebyDistribution

WakebyDistribution[α,β,γ,δ,μ] represents Wakeby distribution with shape parameters β and δ, scale parameters α and γ, and location parameter μ.

WalleniusHypergeometricDistribution

WalleniusHypergeometricDistribution[n,nsucc,ntot,w] represents a Wallenius noncentral hypergeometric distribution.

WaringYuleDistribution

WaringYuleDistribution[α] represents the Yule distribution with shape parameter α.

WaringYuleDistribution[α,β] represents the Waring distribution with shape parameters α and β.

WarpingCorrespondence

WarpingCorrespondence[s1,s2] gives the time warping (DTW) similarity path between sequences s1 and s2.

WarpingCorrespondence[s1,s2,win] uses a window specified by win for local search.

WarpingDistance

WarpingDistance[s1,s2] gives the dynamic time warping (DTW) distance between sequences s1 and s2.

WarpingDistance[s1,s2,win] uses a window specified by win for local search.

WatershedComponents

WatershedComponents[image] computes the watershed transform of image, returning the result as an array in which positive integers label the catchment basins.

WatershedComponents[image,marker] uses a binary image marker to indicate regions where basins may be created.

WatershedComponents[video,…] computes watershed segmentation on frames of video.

WatsonUSquareTest

WatsonUSquareTest[data] tests whether data is normally distributed using the Watson U2 test.

WatsonUSquareTest[data,dist] tests whether data is distributed according to dist using the Watson U2 test.

WatsonUSquareTest[data,dist,"property"] returns the value of "property".

WattsStrogatzGraphDistribution

WattsStrogatzGraphDistribution[n,p] represents the Watts–Strogatz graph distribution for n-vertex graphs with rewiring probability p.

WattsStrogatzGraphDistribution[n,p,k] represents the Watts–Strogatz graph distribution for n-vertex graphs with rewiring probability p starting from a 2k-regular graph.

WaveletBestBasis

WaveletBestBasis[dwd] computes a best basis representation in the DiscreteWaveletData object dwd.

WaveletBestBasis[dwd,cspec] computes a best basis representation using the cost specification cspec.

WaveletFilterCoefficients

WaveletFilterCoefficients[wave,filt] gives the filter coefficients for the symbolic wavelet wave of type filt. 

WaveletImagePlot

WaveletImagePlot[dwd] plots the basis tree of wavelet image coefficients in the DiscreteWaveletData dwd.

WaveletImagePlot[dwd,r] plots coefficients up to refinement level r.

WaveletImagePlot[dwd,r,ifunc] applies the image function ifunc to coefficients and wavelet indexes before plotting.

WaveletListPlot

WaveletListPlot[dwd] plots wavelet transform coefficients in the DiscreteWaveletData dwd.

WaveletListPlot[dwd,wind] plots wavelet transform coefficients corresponding to the wavelet index specification wind.

WaveletListPlot[dwd,wind,func] applies func to coefficients before plotting. 

WaveletListPlot[{dwd1,dwd2,…},…] plots wavelet transform coefficients from several DiscreteWaveletData objects dwd1, dwd2, ….

WaveletMapIndexed

WaveletMapIndexed[f,wd] applies the function f to the arrays of coefficients and indices of a ContinuousWaveletData or DiscreteWaveletData object.

WaveletMapIndexed[f,dwd,wind] applies f to the DiscreteWaveletData coefficients specified by wind.

WaveletMapIndexed[f,cwd,octvoc] applies f to the ContinuousWaveletData coefficients specified by octvoc.

WaveletMatrixPlot

WaveletMatrixPlot[dwd] plots the basis tree of wavelet matrix coefficients in the DiscreteWaveletData dwd.

WaveletMatrixPlot[dwd,r] plots coefficients up to refinement level r.

WaveletMatrixPlot[dwd,r,func] applies func to coefficients before plotting. 

WaveletPhi

WaveletPhi[wave,x] gives the scaling function ϕ(x) for the symbolic wavelet wave evaluated at x.

WaveletPhi[wave] gives the scaling function as a pure function.

WaveletPsi

WaveletPsi[wave,x] gives the wavelet function ψ(x) for the symbolic wavelet wave evaluated at x.

WaveletPsi[wave] gives the wavelet function as a pure function.

WaveletScale

WaveletScale is an option for ContinuousWaveletTransform and related constructs used to specify the smallest resolvable scale. 

WaveletScalogram

WaveletScalogram[wd] plots wavelet vector coefficients in a DiscreteWaveletData or ContinuousWaveletData object wd.

WaveletScalogram[wd,wind] plots wavelet coefficients corresponding to the wavelet index specification wind.

WaveletScalogram[wd,wind,func] applies func to coefficients before plotting. 

WaveletThreshold

WaveletThreshold[dwd] thresholds the detail wavelet coefficients in the DiscreteWaveletData object dwd.

WaveletThreshold[dwd,tspec] thresholds the coefficients using the thresholding specification tspec.

WaveletThreshold[dwd,tspec,wind] thresholds the wavelet coefficients given by the wavelet indices wind.

WavePDEComponent

WavePDEComponent[vars,pars] yields a wave equation PDE term ∂u2/∂t2-c2∇2{x1,…,xn}u with model variables vars and model parameters pars.

WeaklyConnectedComponents

WeaklyConnectedComponents[g] gives the weakly connected components of the graph g.

WeaklyConnectedComponents[g,{v1,v2,…}] gives the weakly connected components that include at least one of the vertices v1, v2, ….

WeaklyConnectedComponents[g,patt] gives the connected components that include a vertex that matches the pattern patt.

WeaklyConnectedComponents[{v->w,…},…] uses rules v->w to specify the graph g. 

WeaklyConnectedGraphComponents

WeaklyConnectedGraphComponents[g] gives the weakly connected components of the graph g.

WeaklyConnectedGraphComponents[g,{v1,v2,…}] gives the weakly connected components that include at least one of the vertices v1, v2, … .

WeaklyConnectedGraphComponents[g,patt] gives the connected components that include a vertex that matches the pattern patt.

WeaklyConnectedGraphComponents[{v->w,…},…] uses rules v->w to specify the graph g. 

WeaklyConnectedGraphQ

WeaklyConnectedGraphQ[g] yields True if the graph g is weakly connected, and False otherwise.

WeakStationarity

WeakStationarity[proc] gives conditions for the process proc to be weakly stationary. 

WeatherData

WeatherData[loc,"property"] gives the most recent measurement for the specified weather property at the location corresponding to loc.

WeatherData[loc,"property",date] gives all measurements during the specified date.

WeatherData[loc,"property",{start,end}] gives a list of dates and measurements for the time interval start to end.

WeatherData[loc,"property",{start,end,step}] gives measurements aggregated over the time period represented by step.

WeatherForecastData

WeatherForecastData[loc] gives the most recent forecast for all weather forecast properties for the specified location.

WeatherForecastData[prop] gives the forecast for the specified property for the current location.

WeatherForecastData[date] gives the forecast at the time or times specified by date for all properties at the current location.

WeatherForecastData[loc,prop] gives the forecast for the property at the specified location.

WeatherForecastData[loc,prop,datespec] gives the forecast at the time or times specified by datespec for the property at the location.

WebAudioSearch

WebAudioSearch["string"] gives a dataset of the top web audio search results for the specified literal string.

WebAudioSearch[query] performs a web audio search using the specified query.

WebAudioSearch[query,format] gives the elements of the web audio search specified by format.

WebAudioSearch[query,format,crit] returns only audio results that satisfy crit.

WebColumn

WebColumn[{expr1,expr2,…}] represents an HTML column containing the expri.

WebColumn[expr,options] displays with expr formatted using the specified option settings. 

WebElementObject

WebElementObject[…] represents an element of an open webpage operated on by WebExecute.

WeberE

WeberE[ν,z] gives the Weber function Eν(z).

WeberE[ν,μ,z] gives the associated Weber function Eνμ(z).

WebExecute

WebExecute[cmd] executes the command cmd in a web browser. 

WebExecute[{cmd1,cmd2,…}] executes a list of commands in sequence.

WebExecute[session,cmds] executes cmds in the specified web session.

WebImage

WebImage[url] gives an image of the webpage specified by url.

WebImage[list] gives images specified by URLs in list.

WebImageSearch

WebImageSearch["string"] gives a list of thumbnails of the top web image search results for the specified literal string.

WebImageSearch[form] gives the top results obtained by doing the web image search specified by form.

WebImageSearch[form, n] picks out the first n top results obtained by doing the web image search specified by form.

WebImageSearch[form,elems] gives the elements of the web image search specified by elems.

WebImageSearch[form, elems, n] picks out the first n elements of the web image search specified by elems.

WebItem

WebItem[expr] represents an HTML element containing expr.

WebItem[expr,options] represents an HTML element formatted using the specified option settings. 

WebItem[XMLElement[expr,…],options] represents an XMLElement formatted using options.

WebRow

WebRow[{expr1, expr2, …}] represents an HTML row containing the expri.

WebRow[expr,options] displays with expr formatted using the specified option settings.

WebSearch

WebSearch["string"] gives a dataset of the top web search results for the specified literal string.

WebSearch[form] gives the top results obtained by doing the web search specified by form.

WebSearch[form,elems] gives the elements of the web search specified by elems.

WebSessionObject

WebSessionObject[…] represents a web browser session started by StartWebSession for use with WebExecute.

WebSessions

WebSessions[] gives the list of all active web sessions.

WebWindowObject

WebWindowObject[…] represents an open window or tab in a web browser.

Wedge

Wedge[x,y,…] displays as x⋀y⋀….

Wednesday

Wednesday is a day of the week.

WeibullDistribution

WeibullDistribution[α,β] represents a Weibull distribution with shape parameter α and scale parameter β.

WeibullDistribution[α,β,μ] represents a Weibull distribution with shape parameter α, scale parameter β, and location parameter μ.

WeierstrassE1

WeierstrassE1[{g2,g3}] gives the value e1 of the Weierstrass elliptic function ℘ at the half-period ω1(g2,g3).

WeierstrassE2

WeierstrassE2[{g2,g3}] gives the value e2 of the Weierstrass elliptic function ℘ at the half-period ω2(g2,g3).

WeierstrassE3

WeierstrassE3[{g2,g3}] gives the value e3 of the Weierstrass elliptic function ℘ at the half-period ω3(g2,g3).

WeierstrassEta1

WeierstrassEta1[{g2,g3}] gives the value η1 of the Weierstrass zeta function ζ at the half-period ω1(g2,g3).

WeierstrassEta2

WeierstrassEta2[{g2,g3}] gives the value η2 of the Weierstrass zeta function ζ at the half-period ω2(g2,g3).

WeierstrassEta3

WeierstrassEta3[{g2,g3}] gives the value η3 of the Weierstrass zeta function ζ at the half-period ω3(g2,g3).

WeierstrassHalfPeriods

WeierstrassHalfPeriods[{g2,g3}] gives the half‐periods {ω1,ω3} for Weierstrass elliptic functions corresponding to the invariants {g2,g3}.

WeierstrassHalfPeriodW1

WeierstrassHalfPeriodW1[{g2,g3}] gives the half-period ω1 for Weierstrass elliptic functions corresponding to the invariants {g2,g3}.

WeierstrassHalfPeriodW2

WeierstrassHalfPeriodW2[{g2,g3}] gives the half-period ω2 for the Weierstrass elliptic functions corresponding to the invariants {g2,g3}.

WeierstrassHalfPeriodW3

WeierstrassHalfPeriodW3[{g2,g3}] gives the half-period ω3 for the Weierstrass elliptic functions corresponding to the invariants {g2,g3}.

WeierstrassInvariantG2

WeierstrassInvariantG2[{ω,ω′}] gives the invariant g2 for the Weierstrass elliptic functions corresponding to the half‐periods {ω,ω′}.

WeierstrassInvariantG3

WeierstrassInvariantG3[{ω,ω′}] gives the invariant g3 for the Weierstrass elliptic functions corresponding to the half‐periods {ω,ω′}.

WeierstrassInvariants

WeierstrassInvariants[{ω1,ω3}] gives the invariants {g2,g3} for Weierstrass elliptic functions corresponding to the half‐periods {ω1,ω3}. 

WeierstrassP

WeierstrassP[u,{g2,g3}] gives the Weierstrass elliptic function ℘(u;g2,g3). 

WeierstrassPPrime

WeierstrassPPrime[u,{g2,g3}] gives the derivative of the Weierstrass elliptic function ℘(u;g2,g3). 

WeierstrassSigma

WeierstrassSigma[u,{g2,g3}] gives the Weierstrass sigma function σ(u;g2,g3). 

WeierstrassZeta

WeierstrassZeta[u,{g2,g3}] gives the Weierstrass zeta function ζ(u;g2,g3). 

WeightedAdjacencyGraph

WeightedAdjacencyGraph[wmat] gives the graph with weighted adjacency matrix wmat.

WeightedAdjacencyGraph[{v1,v2,…},wmat] gives the graph with vertices vi and weighted adjacency matrix wmat.

WeightedAdjacencyMatrix

WeightedAdjacencyMatrix[g] gives the adjacency matrix of edge weights of the graph g.

WeightedAdjacencyMatrix[{v->w,…}] uses rules v->w to specify the graph g. 

WeightedData

WeightedData[{x1,x2,…},{w1,w2,…}] represents observations xi with weights wi.

WeightedData[{x1,x2,…},fn] represents observations xi with weighting function fn.

WeightedGraphQ

WeightedGraphQ[g] yields True if the graph g is a weighted graph and False otherwise.

Weights

Weights is an option for various fitting and other functions which specifies weights to associate with data elements.

WelchWindow

WelchWindow[x] represents a Welch window function of x.

WelchWindow[x,α] uses the parameter α.

WheelGraph

WheelGraph[n] gives the wheel graph with n vertices Wn.

WhenEvent

WhenEvent[event,action] specifies an action that occurs when the event triggers it for equations in NDSolve and related functions. 

Which

Which[test1,value1,test2,value2,…] evaluates each of the testi in turn, returning the value of the valuei corresponding to the first one that yields True. 

While

While[test,body] evaluates test, then body, repetitively, until test first fails to give True. 

White

White represents the color white in graphics or style specifications. 

WhiteNoiseProcess

WhiteNoiseProcess[] represents a Gaussian white noise process with mean 0 and standard deviation 1.

WhiteNoiseProcess[σ] represents a Gaussian white noise process with mean 0 and standard deviation σ.

WhiteNoiseProcess[dist] represents a white noise process based on the distribution dist.

WhitePoint

WhitePoint is an option for ColorConvert, ChromaticityPlot and other functions to specify the white point.

Whitespace

Whitespace represents a sequence of whitespace characters in StringExpression.

WhitespaceCharacter

WhitespaceCharacter represents a single whitespace character in StringExpression.

WhittakerM

WhittakerM[k,m,z] gives the Whittaker function Mk,m(z). 

WhittakerW

WhittakerW[k,m,z] gives the Whittaker function Wk,m(z). 

WienerFilter

WienerFilter[data,r] removes noise from data by applying a range-r Wiener filter.

WienerFilter[data,r,ns] assumes an additive noise power value ns.

WienerFilter[data,{r1,r2,…},…] uses radius ri at level i in data.

WienerProcess

WienerProcess[μ,σ] represents a Wiener process with a drift μ and volatility σ.

WienerProcess[] represents a standard Wiener process with drift 0 and volatility 1.

WignerD

WignerD[{j,m1,m2},ψ,θ,ϕ] gives the Wigner D-function Dm1,m2j(ψ,θ,ϕ).

WignerD[{j,m1,m2},θ,ϕ] gives the Wigner D-function Dm1,m2j(0,θ,ϕ).

WignerD[{j,m1,m2},θ] gives the Wigner D-function Dm1,m2j(0,θ,0).

WignerSemicircleDistribution

WignerSemicircleDistribution[r] represents a Wigner semicircle distribution with radius r centered at the origin.

WignerSemicircleDistribution[a,r] represents a Wigner semicircle distribution with radius r centered at a.

WikidataData

WikidataData[item,property] gives the values of the specified property for the given item.

WikidataData[{item1,item2,…},property] gives values for each of the itemi.

WikidataData[item,{property1,property2,…}] gives values for each of the propertyi.

WikidataData[items,properties] gives values for each of the properties for each of the items.

WikidataSearch

WikidataSearch["keywords"] returns a list of Wikidata items whose labels include the given keywords.

WikidataSearch["type"->"keywords"] returns a list of Wikidata identifiers of the specified type.

WikipediaData

WikipediaData[article] gives the plain text of the specified Wikipedia article.

WikipediaData[{article1,article2,...}] gives the texts for each of the articles.

WikipediaData[article,property,options] gives the value of the specified property, modified by optional parameters, for the given Wikipedia article.

WikipediaData["Category"->category,property,options] gives the value of the specified property, modified by optional parameters, for the given Wikipedia category.

WikipediaData["PageID"->pageid,property,options] gives the value of the specified property, modified by optional parameters, for the article corresponding to the given numerical Wikipedia page ID.

WikipediaSearch

WikipediaSearch[keywords] returns a list of Wikipedia articles whose titles include the given keywords.

WikipediaSearch["Title"->keywords,options] returns a list of Wikipedia articles whose titles include the given keywords.

WikipediaSearch["Category"->keywords,options] returns a list of Wikipedia categories whose titles include the given keywords.

WikipediaSearch["Content"->keywords] returns a list of Wikipedia articles whose content includes the given keywords.

WikipediaSearch[loc] returns a list of Wikipedia articles whose associated coordinates are near the given location.

WilksW

WilksW[m1,m2] gives Wilks's  for the matrices m1 and m2.

WilksWTest

WilksWTest[m1,m2] tests whether the matrices m1 and m2 are independent.

WilksWTest[…,"property"] returns the value of "property".

WindDirectionData

WindDirectionData[] gives the most recent measurement for wind direction near the current location.

WindDirectionData[datespec] gives the wind direction value for the specified time near the current location.

WindDirectionData[locationspec] gives the most recent measurement for wind direction near the specified location.

WindDirectionData[locationspec,datespec] gives the value or values for the specified date and location.

WindDirectionData[{{location1,date1},{location2,date2},…}] gives values for all specified locations on the specified dates.

WindingCount

WindingCount[contour,p] gives the count of the number of times a closed curve winds around a point p.

WindingPolygon

WindingPolygon[{p1,p2,…,pn}] gives a polygon representing all points for which the closed contour p1,p2,…,pn,p1 winds around at least once. 

WindingPolygon[{{p11,p12,…},{p21,p22,…},…}] gives a polygon from the closed contours p11,p12,… and p21,p22,….

WindingPolygon[…,"wrule"] uses the specified winding rule "wrule" to define the polygon.

WindowTitle

WindowTitle is an option that specifies the title to give for a window. 

WindSpeedData

WindSpeedData[] gives the most recent measurement for wind speed near the current location.

WindSpeedData[datespec] gives the wind speed value for the specified time near the current location.

WindSpeedData[locationspec] gives the most recent measurement for wind speed near the specified location.

WindSpeedData[locationspec,datespec] gives the value or values for the specified date and location.

WindSpeedData[{{location1,date1},{location2,date2},…}] gives values for all specified locations on the specified dates.

WindVectorData

WindVectorData[] gives the most recent weather station measurement for wind vector near the current location.

WindVectorData[datespec] gives the wind vector value for the specified time near the current location.

WindVectorData[locationspec] gives the most recent measurement for wind vector near the specified location.

WindVectorData[locationspec,datespec] gives the value or values for the specified date and location.

WindVectorData[{{location1,date1},{location2,date2},…}] gives values for all specified locations on the specified dates.

WinsorizedMean

WinsorizedMean[list,f] gives the mean of the elements in list after replacing the fraction f of the smallest and largest elements by the remaining extreme values.

WinsorizedMean[list,{f1,f2}] gives the mean when the fraction f1 of the smallest elements and the fraction f2 of the largest elements are replaced by the remaining extreme values.

WinsorizedMean[list] gives the 5% winsorized mean WinsorizedMean[list,0.05].

WinsorizedMean[dist,…] gives the winsorized mean of a univariate distribution dist.

WinsorizedVariance

WinsorizedVariance[list,f] gives the variance of the elements in list after replacing the fraction f of the smallest and largest elements by the remaining extreme values.

WinsorizedVariance[list,{f1,f2}] gives the variance when the fraction f1 of the smallest elements and the fraction f2 of the largest elements are replaced by the remaining extreme values.

WinsorizedVariance[list] gives the 5% winsorized variance WinsorizedVariance[list,0.05].

WinsorizedVariance[dist,…] gives the winsorized variance of a univariate distribution dist.

WishartMatrixDistribution

WishartMatrixDistribution[ν,Σ] represents a Wishart matrix distribution with ν degrees of freedom and covariance matrix Σ.

With

With[{x=x0,y=y0,…},expr] specifies that all occurrences of the symbols x, y, … in expr should be replaced by x0, y0, …. 

WithCleanup

WithCleanup[expr,cleanup] evaluates expr, running cleanup before returning the result, even if an abort, throw, etc. was generated during the evaluation of expr.

WithCleanup[init,expr,cleanup] evaluates init before evaluating expr, blocking aborts, throws, etc. in both init and cleanup.

WithLock

WithLock[File["path"],expr] locks the file path, evaluates expr, then releases the file.

WithLock[LocalSymbol["name"],expr] locks the local symbol name, evaluates expr, then releases the local symbol.

WithLock[var,expr] locks the shared variable var, evaluates expr, then releases the shared variable.

WolframAlpha

WolframAlpha["query"] sends query to Wolfram|Alpha and imports the output.

WolframAlpha["query",format] imports the output according to the specified format.

WolframLanguageData

WolframLanguageData[entity,property] gives the value of the specified property for the Wolfram Language symbol entity.

WolframLanguageData[{entity1,entity2,…},property] gives a list of property values for the specified Wolfram Language symbol entities.

WolframLanguageData[entity,property,annotation] gives the specified annotation associated with the given property.

Word

Word represents a word in Read, Find, and related functions. 

WordBoundary

WordBoundary represents a boundary between words for purposes of matching in StringExpression.

WordCharacter

WordCharacter represents a letter or digit character in StringExpression.

WordCount

WordCount["string"] gives the total number of words in string.

WordCounts

WordCounts["string"] gives an association whose keys are the distinct words identified in string, and whose values give the number of times those words appear in string.

WordCounts["string",n] gives counts of the distinct n-grams consisting of runs of n words in string.

WordCounts[{string1,string2,…},…] gives the counts for each of the stringi.

WordData

WordData["word","property"] gives the specified property for the English word "word".

WordData["word"] gives a list of full word specifications representing possible uses and senses of "word".

WordData[wordspec,"property"] gives a property for a particular word specification.

WordDefinition

WordDefinition["word"] gives the dictionary definitions available for "word".

WordFrequency

WordFrequency[text,word] gives the frequency of word in text.

WordFrequency[text,{word1,word2,…}] gives an association of the frequencies of each of the wordi.

WordFrequencyData

WordFrequencyData[word] gives the frequency of word in typical published English text.

WordFrequencyData[{word1,word2,…}] gives an association of frequencies of the wordi.

WordFrequencyData[word,"TimeSeries"] gives a time series for the frequency of word in typical published English text.

WordFrequencyData[word,"TimeSeries",datespec] gives a time series for dates specified by datespec.

WordFrequencyData[word,"prop"] gives property prop of the word frequency.

WordList

WordList[] gives a list of common words.

WordList[type] gives a list of words of the specified type.

WordOrientation

WordOrientation is an option for WordCloud that specifies the orientations in which words appear.

WordSearch

WordSearch is an option for Find and FindList that specifies whether the text searched for must appear as a word. 

WordSelectionFunction

WordSelectionFunction is an option for WordCloud and other functions that specifies which words to use.

WordSeparators

WordSeparators is an option for Read, Find, and related functions that specifies the list of strings to be taken as delimiters for words. 

WordSpacings

WordSpacings is an option for WordCloud that specifies the empty space to be added around each word. 

WordStem

WordStem["word"] gives a stemmed form of word, removing plurals, inflections, etc.

WordTranslation

WordTranslation["word",lang] gives translations for word into the language lang.

WordTranslation["word",lang1->lang2] gives translations for word from lang1 to lang2.

WorkingPrecision

WorkingPrecision is an option for various numerical operations that specifies how many digits of precision should be maintained in internal computations. 

Write

Write[channel,expr1,expr2,…] writes the expressions expri in sequence, followed by a newline, to the specified output channel.

WriteLine

WriteLine[stream, "string"] writes "string", followed by a newline, to the specified output stream.

WriteLine[proc, "string"] writes "string" to an external process proc.

WriteString

WriteString["file","string"] writes "string" to a file.

WriteString[channel,"string"] writes "string" to a stream or process.

WriteString[channel,expr1,expr2,…] converts the expri to strings, and then writes them in sequence to the specified output channel. 

Wronskian

Wronskian[{y1,y2,…},x] gives the Wronskian determinant for the functions y1,y2,… depending on x.

Wronskian[eqn,y,x] gives the Wronskian determinant for the basis of the solutions of the linear differential equation eqn with dependent variable y and independent variable x. 

Wronskian[eqns,{y1,y2,…},x] gives the Wronskian determinant for the system of linear differential equations eqns.

XMLElement

XMLElement[tag,{attr1->val1,…},{data1,…}] represents an element in symbolic XML.

XMLObject

XMLObject["type"] represents the head of an XML object in symbolic XML.

XMLTemplate

XMLTemplate["string"] yields a TemplateObject that represents an XML template to be applied using functions like TemplateApply.

XMLTemplate[src] uses File[…], URL[…], or CloudObject[…] as the source for the string template.

XMLTemplate[form,args] yields a TemplateObject with arguments, suitable for cloud deployment or other evaluation.

Xnor

Xnor[e1,e2,…] is the logical XNOR (not XOR) function. It gives True if an even number of the ei are True, and the rest are False. It gives False if an odd number of the ei are True, and the rest are False. 

Xor

Xor[e1,e2,…] is the logical XOR (exclusive OR) function. It gives True if an odd number of the ei are True, and the rest are False. It gives False if an even number of the ei are True, and the rest are False. 

XYZColor

XYZColor[x,y,z] represents a color in the XYZ color space with tristimulus values x, y and z.

XYZColor[x,y,z,a] specifies opacity a. 

XYZColor["string"] returns a color from an HTML color name etc.

XYZColor[color] returns the XYZ representation of color.

Yellow

Yellow represents the color yellow in graphics or style specifications. 

Yesterday

Yesterday gives a DateObject representing the previous day.

YuleDissimilarity

YuleDissimilarity[u,v] gives the Yule dissimilarity between Boolean vectors u and v.

ZernikeR

ZernikeR[n,m,r] gives the radial Zernike polynomial Rnm(r).

ZeroSymmetric

ZeroSymmetric[{s1,…,sn}] represents the symmetry of a zero tensor in the slots si.

ZeroTest

ZeroTest is an option to various linear algebra functions that gives a function to use in testing whether symbolic expressions should be treated as zero.

ZeroWidthTimes

ZeroWidthTimes is an option for selections that specifies whether blank spaces representing multiplication are explicitly shown.

Zeta

Zeta[s] gives the Riemann zeta function ζ(s). 

Zeta[s,a] gives the generalized Riemann zeta function ζ(s,a). 

ZetaZero

ZetaZero[k] represents the kth zero of the Riemann zeta function on the critical line.

ZetaZero[k,t] represents the kth zero with imaginary part greater than t.

ZIPCodeData

ZIPCodeData[entity,property] gives the value of the specified property for the ZIP code entity.

ZIPCodeData[{entity1,entity2,…},property] gives a list of property values for the specified ZIP code entities.

ZIPCodeData[entity,property,annotation] gives the specified annotation associated with the given property.

ZipfDistribution

ZipfDistribution[ρ] represents a zeta distribution with parameter ρ.

ZipfDistribution[n,ρ] represents a Zipf distribution with range n.

ZTransform

ZTransform[expr,n,z] gives the Z transform of expr. 

ZTransform[expr,{n1,…,nm},{z1,…,zm}] gives the multidimensional Z transform of expr.

AcyclicGraphQ

AcyclicGraphQ[g] yields True if the graph g is an acyclic graph and False otherwise.

AllMatch

AllMatch[{e1,e2,…},form] yields True if ei matches the pattern form for all of the ei.

AllMatch[expr,form,level] tests parts of expr at level level.

AllMatch[form] represents an operator form of AllMatch that can be applied to an expression.

AllSameBy

AllSameBy[{e1,e2,…},f] tests whether all the f[ei] are the same.

AllSameBy[f] represents an operator form of AllSameBy that can be applied to an expression.

AnyMatch

AnyMatch[{e1,e2,…},form] yields True if ei matches the pattern form for any of the ei.

AnyMatch[expr,form,level] tests parts of expr at level level.

AnyMatch[form] represents an operator form of AnyMatch that can be applied to an expression.

AppellF2

AppellF2[a,b1,b2,c1,c2,x,y] is the Appell hypergeometric function of two variables F2(a;b1,b2;c1,c2;x,y). 

AppellF3

AppellF3[a1,a2,b1,b2,c,x,y] is the Appell hypergeometric function of two variables F3(a;b1,b2;c1,c2;x,y). 

AppellF4

AppellF4[a,b,c1,c2,x,y] is the Appell hypergeometric function of two variables F4(a;b;c1,c2;x,y). 

ArcCosDegrees

ArcCosDegrees[z] gives the arc cosine in degrees of the complex number z.

ArcCotDegrees

ArcCotDegrees[z] gives the arc cotangent in degrees of the complex number z.

ArcCscDegrees

ArcCscDegrees[z] gives the arc cosecant in degrees of the complex number z. 

ArcSecDegrees

ArcSecDegrees[z] gives the arc secant in degrees of the complex number z. 

ArcSinDegrees

ArcSinDegrees[z] gives the arc sine in degrees of the complex number z.

ArcTanDegrees

ArcTanDegrees[z] gives the arc tangent in degrees of the complex number z.

ArrayDot

ArrayDot[a,b,k] computes the product of arrays a and b obtained by summing up products of terms over the last k dimensions of a and the first k dimensions of b.

ArrayDot[a,b,{{s1,t1},{s2,t2},…}] computes the product of arrays a and b obtained by summing up products of terms over the pairs {si,ti} of dimensions.

ArraySymbol

ArraySymbol[a] represents an array with name a.

ArraySymbol[a,{n1,n2,…}] represents an n1×n2×… array.

ArraySymbol[a,{n1,n2,…},dom] represents an array with elements in the domain dom.

ArraySymbol[a,{n1,n2,…},dom, sym] represents an array with the symmetry sym.

BitFlip

BitFlip[n,k] flips the bit corresponding to the coefficient of 2k in the integer n. 

BlockDiagonalMatrix

BlockDiagonalMatrix[{d1,d2,…}] represents the block diagonal matrix with diagonal blocks di as a structured array.

BlockDiagonalMatrix[mat] converts the block diagonal matrix mat to a structured array.

BlockLowerTriangularMatrix

BlockLowerTriangularMatrix[lmat] represents the block lower triangular matrix lmat as a structured array.

BlockUpperTriangularMatrix

BlockUpperTriangularMatrix[umat] represents the block upper triangular matrix umat as a structured array.

BuckyballGraph

BuckyballGraph[] gives the buckyball graph.

BuckyballGraph[n] gives the order‐n buckyball graph.

BuckyballGraph[n,"class"] gives the order‐n buckyball graph of class "class".

BuildCompiledComponent

BuildCompiledComponent[comp] builds the compiled component comp.

BuildCompiledComponent[comp,dest] builds the compiled component comp, placing the result in dest.

CaputoD

CaputoD[f,{x,α}] gives the Caputo fractional differintegral C0Dxαf(x) of the function f(x).

Cast

Cast[val,type] converts val to the type type, for use in compiled code.

Cast[val,type,method] uses the specified casting method.

CauchyMatrix

CauchyMatrix[x,y] represents the Cauchy matrix given by the generating vectors x and y as a structured array.

CauchyMatrix[x] is equivalent to CauchyMatrix[x,x].

CauchyMatrix[cmat] converts a Cauchy matrix cmat to a structured array. 

CircularArcThrough

CircularArcThrough[{p1,p2,…}] represents a circular arc passing through the points pi.

CircularArcThrough[{p1,p2,…},q] represents a circular arc with center q.

CircularArcThrough[{p1,p2,…},q,r] represents a circular arc with radius r.

CircumscribedBall

CircumscribedBall[{p1,p2,…}] gives a ball with minimal radius that encloses the points p1, p2, ….

Comap

Comap[{f1,f2,…},x] gives {f1[x],f2[x],…}.

Comap[fs,x,levelspec] applies parts of fs specified by levelspec to x.

Comap[fs] represents an operator form of Comap that can be applied to an expression.

ComapApply

ComapApply[{f1,f2,…},expr] gives {Apply[f1,expr],Apply[f2,expr],…}.

ComapApply[fs] represents an operator form of ComapApply that can be applied to an expression.

ConformDates

ConformDates[dates] returns a list of dates where all dates are made to have conforming properties, including calendar, time zone and granularity.

ConformDates[dates,rdate] returns all dates in a form consistent with the reference date rdate.

ContourIntegrate

ContourIntegrate[f,z∈cont] gives the integral of f along the contour defined by cont in the complex plane.

CosDegrees

CosDegrees[θ] gives the cosine of θ degrees. 

CotDegrees

CotDegrees[θ] gives the cotangent of θ degrees. 

CreateSemanticSearchIndex

CreateSemanticSearchIndex[source] creates a search index from the data in source.

CreateSemanticSearchIndex[{source1,…}] creates a search index with a collection of sources sourcei.

CreateSemanticSearchIndex[{source1->val1,…}] associates the source sourcei to the value vali.

CreateSemanticSearchIndex[data,"name"] gives the search index the specified name.

CreateTypeInstance

CreateTypeInstance[type,arg1,arg2,…] creates an instance of a type in compiled code.

CreateTypeInstance[productType,<|field1->x1,field2->x2,…|>] creates an instance of a product type and initializes its fields.

CscDegrees

CscDegrees[θ] gives the cosecant of θ degrees. 

CumulativeFeatureImpactPlot

CumulativeFeatureImpactPlot[model,data] plots the cumulative impact of the value of each feature in data on the result of model.

CumulativeFeatureImpactPlot[model] estimates the feature impacts using synthetic data.

CumulativeFeatureImpactPlot[model->fname,…] plots only the impact of the specified feature fname.

CumulativeFeatureImpactPlot[model->fname->class,…] plots only the impact on the classification class.

DateDistribution

DateDistribution[dist,dunit,dorig] represents a distribution dist of dates with date scale unit dunit and date origin dorig. 

DateGranularity

DateGranularity is an option that determines the calendar granularity of generated dates.

Decimal

Decimal is a setting for the ColumnAlignments option of GridBox which states that numbers should align along the decimal place.

DeclareCompiledComponent

DeclareCompiledComponent["name",decls] adds declarations decls to compiled component "name".

DeclareCompiledComponent["name",field->spec] adds the specification spec to the specified field in the compiled component "name".

DeleteAdjacentDuplicates

DeleteAdjacentDuplicates[list] deletes all duplicates in runs of identical elements in list.

DeleteAdjacentDuplicates[list,test] applies test to pairs of consecutive elements to determine whether they should be considered duplicates.

DeleteElements

DeleteElements[list,{e1,e2,…}] removes all instances of elements ei from list.

DeleteElements[list,n->{e1,e2,…}] removes up to n instances of each ei from list.

DeleteElements[list,{n1,n2,…}->{e1,e2,…}] removes up to ni instances of ei from list.

DFixedPoints

DFixedPoints[eqn,x[t],t] gives the fixed points for a differential equation.

DFixedPoints[{eqn1,eqn2,…},{x1[t],x2[t],…},t] gives the fixed points for a system of differential equations.

Diff

Diff[first,second] returns a representation of the diffs between first and second.

Diff[first,second,format] represents the diffs in the indicated format.

Diff3

Diff3[ancestor,first,second] returns a representation of the three-way diff between ancestor and two independently changed versions of ancestor.

Diff3[ancestor,first,second,format] represents the diffs in the indicated format.

DiffApply

DiffApply[diffobj,expr] returns the result of applying the given DiffObject to the expression expr.

DiffApply[diffobj,expr,File["file"]] writes the result of changing expr to file.

DiffGranularity

DiffGranularity is an option to Diff and related functions that indicates with what granularity to compare the given expressions.

DiffIgnore

DiffIgnore is an option to Diff and related functions that specifies what elements to ignore when computing diffs.

DiffIncludeMatches

DiffIncludeMatches is an option for Diff and related functions that specifies whether to include matching data in the resulting DiffObject.

DiffInputFunction

DiffInputFunction is an option for Diff and related functions that specifies how the input expressions should be preprocessed.

DiffObject

DiffObject[v, type, data] represents a sequence of diffs for transforming objects of the indicated type.

DigitSum

DigitSum[n] gives the sum of the decimal digits in the integer n.

DigitSum[n,b] gives the sum of the base b digits in the integer n.

DigitSum[n,b,k] gives the sum of the first k base b digits in the integer n.

DigitSum[n,b,-k] gives the sum of the last k base b digits in the integer n.

DigitSum[n,MixedRadix[blist]] uses the mixed radix with list of bases blist.

DiscreteInputOutputModel

DiscreteInputOutputModel[{g0,g1,…,gn-1},u] represents a discrete-time model with input u and output y=gi(u) at sampling instant i.

DiscreteInputOutputModel[{g0,g1,…,gn-1},u,y] can be used to specify outputs gi(u,y) that also depend on the output variables y.

DiscreteInputOutputModel[…,{{u1,{…,u10}},…},{{y1,{…,y10}},…}] specifies input and output values for each signal for instants k<=0.

DownValuesFunction

DownValuesFunction[sym] represents a function that uses definitions attached to sym when compiling.

DSolveChangeVariables

DSolveChangeVariables[dsolve,u,t,trans] changes the solution function in dsolve to u(t) using the transformation trans.

DSolveChangeVariables[dsolve,{u1,u2,…},t,trans] changes the solution functions in the system to {u1(t),…,un(t)}.

DSolveChangeVariables[dsolve,u,{t1,…,tn},trans] changes the solution function in the partial differential equation to u(t1,…,tn).

DStabilityConditions

DStabilityConditions[eqn,x[t],t] gives the fixed points and stability conditions for a differential equation.

DStabilityConditions[{eqn1,eqn2,…},{x1[t],x2[t],…},t] gives the fixed points and stability conditions for a system of differential equations.

DStabilityConditions[{eqn1,eqn2,…},{x1[t],x2[t],…},t,{pnt1,pnt2,…}] gives the stability conditions for the given fixed points.

ElectricCurrentDensityValue

ElectricCurrentDensityValue[pred,vars,pars] represents a current density boundary condition for PDEs with predicate pred indicating where it applies, with model variables vars and global parameters pars.

ElectricCurrentDensityValue[pred,vars,pars,lkey] represents a current density boundary condition with local parameters specified in pars[lkey].

ElectricCurrentPDEComponent

ElectricCurrentPDEComponent[vars,pars] yields an electric current PDE term with variables vars and parameters pars.

ElectricFluxDensityValue

ElectricFluxDensityValue[pred,vars,pars] represents an electric flux density boundary condition for PDEs with predicate pred indicating where it applies, with model variables vars and global parameters pars.

ElectricFluxDensityValue[pred,vars,pars,lkey] represents an electric flux density boundary condition with local parameters specified in pars[lkey].

ElectricPotentialCondition

ElectricPotentialCondition[pred,vars,pars] represents an electric potential surface boundary condition for PDEs with predicate pred indicating where it applies, with model variables vars and global parameters pars.

ElectricPotentialCondition[pred,vars,pars,lkey] represents an electric potential surface boundary condition with local parameters specified in pars[lkey].

ElectricSymmetryValue

ElectricSymmetryValue[pred,vars,pars] represents an electric symmetry boundary condition for PDEs with predicate pred indicating where it applies, with model variables vars and global parameters pars.

ElectricSymmetryValue[pred,vars,pars,lkey] represents an electric symmetry boundary condition with local parameters specified in pars[lkey].

ElectrostaticPDEComponent

ElectrostaticPDEComponent[vars,pars] yields an electrostatic PDE term with variables vars and parameters pars.

EntityType

EntityType["type"] represents an entity type with the specified name.

EntityType["type"->child1->child2->…] represents a child entity type of "type".

EstimatedPointNormals

EstimatedPointNormals[{p1,p2,…}] estimates normal vectors for the points p1,p2,….

EstimatedPointNormals[mreg] estimates normals vectors for the vertices of the mesh region mreg.

ExternalOperation

ExternalOperation["Eval","code"] represents an external evaluation of "code".

ExternalOperation["Eval","code",assoc] represents an external evaluation of "code" with parameters given by assoc.

ExternalOperation["Call",func,arg1,arg2,…] calls the function func with the given arguments arg1, arg2, ….

ExternalOperation["GetAttribute",obj,"attr"] gets the attribute "attr" of obj.

ExternalOperation["SetAttribute",obj,"attr",val] sets the attribute "attr" of obj to the given value val.

ExternalOperation["Cast",obj,"type"] casts obj to the given "type".

ExternalOperation["op", arg1,arg2,…] represents the external operation named "op" using arguments arg1, arg2, ….

FeatureValueDependencyPlot

FeatureValueDependencyPlot[model,data] plots the dependency of the result of model on the value of a particular feature in data.

FeatureValueDependencyPlot[model] estimates the feature value dependency using synthetic data.

FeatureValueDependencyPlot[model->fname,…] plots only the dependency on the specified feature fname.

FeatureValueDependencyPlot[model->fname->class,…] plots only the dependency on the classification class.

FeatureValueImpactPlot

FeatureValueImpactPlot[model,data] plots the impact of the value of a given feature in data on the result of model.

FeatureValueImpactPlot[model] estimates the feature value impact using synthetic data.

FeatureValueImpactPlot[model->fname,…] plots only the impact of the specified feature fname.

FeatureValueImpactPlot[model->fname->class,…] plots only the impact on the classification class.

FiniteField

FiniteField[p,d] gives a finite field with pd elements.

FiniteField[p,f] gives the finite field p[α]/〈f(α)〉, where f(α) is an irreducible polynomial in p[α].

FiniteField[p,…,rep] uses field element representation rep, either "Polynomial" or "Exponential".

FiniteFieldElementPrimitiveQ

FiniteFieldElementPrimitiveQ[a] tests whether a is a primitive element of its ambient field.

FiniteFieldEmbedding

FiniteFieldEmbedding[ff1,ff2] gives an embedding of the finite field ff1 in the finite field ff2.

FiniteFieldEmbedding[e1->e2] represents the embedding of the ambient field of e1 in the ambient field of e2, which maps e1 to e2.

FiniteFieldIndex

FiniteFieldIndex[u] gives the index of the FiniteFieldElement object u.

FluidFlowPDEComponent

FluidFlowPDEComponent[vars,pars] yields a flow PDE term with variables vars and parameters pars.

ForAllType

ForAllType[x,type] represents a type parameterized by x.

ForAllType[x,cond,type] represents a type satisfying cond.

ForAllType[{x1,x1,…},cond,type] represents a type with multiple parameters.

ForeignCallback

ForeignCallback[…] represents a foreign callback that can be called from external libraries.

ForeignFunction

ForeignFunction[args] represents a function that has been loaded from a library.

ForeignFunctionLoad

ForeignFunctionLoad[lib,fun,{argtype1,argtype2,…}->rettype] loads the function fun with the specified argument and output types from the library lib.

ForeignFunctionLoad[ptr,{argtype1,argtype2,…}->rettype] creates a foreign function from the function pointer ptr.

ForeignPointerLookup

ForeignPointerLookup[lib,fun] returns the pointer to the function fun in the library lib.

FromFiniteField

FromFiniteField[a,ff] converts the element a of the prime subfield of the finite field ff to an integer.

FromFiniteField[expr,ff,t] converts the elements of the finite field ff in the coefficients of the rational expression expr to polynomials in t, where t represents the field generator.

FromFiniteFieldIndex

FromFiniteFieldIndex[ind,ff] gives the element of the finite field ff with index ind.

FromLunationNumber

FromLunationNumber[ln] returns the date corresponding to the lunation number ln.

FromLunationNumber[scheme,ln] returns the date corresponding to the lunation number in the given counting scheme.

FromRawPointer

FromRawPointer[p] returns the value referred to by the pointer p for use in compiled code.

FromRawPointer[array,offset] returns the value of a C array at an offset. 

FullMoon

FullMoon[] gives the date of the next full moon.

FullMoon[date] gives the date of the first full moon after the given date.

GraphJoin

GraphJoin[g1,g2] gives the graph join of the graphs g1 and g2.

GraphProduct

GraphProduct[g1,g2] gives the Cartesian product of the graphs g1 and g2.

GraphProduct[g1,g2,"op"] gives the product of type "op" for the graphs g1 and g2

GraphSum

GraphSum[g1,g2] gives the graph sum of the graphs g1 and g2.

GraphTriangleCount

GraphTriangleCount[g] gives the number of triangles in the graph g.

Haloing

Haloing[] is a two‐dimensional directive specifying that graphics objects are to be drawn with a halo.

Haloing[col] uses the specified color col for the halo.

Haloing[col,w] uses the specified width w for the halo.

Haloing[col,w,r] applies a blur effect with radius r to the halo.

HermitianMatrix

HermitianMatrix[hmat] converts the Hermitian matrix hmat to a structured array.

InertEvaluate

InertEvaluate[inertExpr] evaluates an "InertExpression", returning a new "InertExpression" in compiled code.

InertExpression

InertExpression[expr] creates an inert expression in compiled code.

InscribedBall

InscribedBall[{p1,p2,…}] gives the largest ball that lies inside the convex hull of the points p1,p2,….

IntegrateChangeVariables

IntegrateChangeVariables[integral,u,trans] changes the variable in integral to the new variable u using the transformation trans. 

IntegrateChangeVariables[integral,{u,v,…},trans] changes the variables to the new variables u, v, ….

IntermediateTest

IntermediateTest[input] creates an intermediate test to determine whether input evaluates to True.

IntermediateTest[input,expected] creates an intermediate test to determine whether input evaluates to expected.

IntermediateTest[input,expected,messages] creates an intermediate test that is expected to generate the list of message names messages.

LayeredGraph

LayeredGraph[g] creates a graph with vertices and edges from the graph g represented as a layered plot.

LayeredGraph[{e1,e2,…}] creates a graph with edges ej represented as a layered plot.

LayeredGraph[{…,w[ei],…}] creates a graph with edges ei with features defined by the symbolic wrapper w.

LayeredGraph[…,v->pos] places the dominant vertex v in the plot at position pos.

LayeredGraph3D

LayeredGraph3D[g] creates a graph with vertices and edges from the graph g represented as a 3D layered plot.

LayeredGraph3D[{e1,e2,…}] creates a graph with edges ej represented as a 3D layered plot.

LayeredGraph3D[{…,w[ei],…}] creates a graph with edges ei with features defined by the symbolic wrapper w.

LayeredGraph3D[…,v->pos] places the dominant vertex v in the plot at position pos.

LibraryFunctionDeclaration

LibraryFunctionDeclaration["extName",lib,type] represents a function declaration that exposes the library function extName with the type type from the library lib, for use in compiled code.

LibraryFunctionDeclaration[name->"extName",lib,type] aliases the function with name in compiled code.

LibraryFunctionDeclaration[nameSpec,type] assumes that the library will be loaded by the time the function is compiled.

LineIntegrate

LineIntegrate[f,{x,y,…}∈curve] computes the scalar line integral of the function f[x,y,…] over the curve.

LineIntegrate[{p,q,…},{x,y,…}∈curve] computes the vector line integral of the vector function {p[x,y,…],q[x,y,…],…}.

LiteralType

LiteralType[x] represents a literal value x for use as a type.

LLMConfiguration

LLMConfiguration[…] represents a configuration for an LLM.

LLMConfiguration[prop->val] creates a configuration based on $LLMEvaluator with the specified property set to val.

LLMConfiguration[<|prop1->val1,prop2->val2,...|>] specifies several properties and values.

LLMConfiguration[LLMConfiguration[…],propspec] creates a configuration based on an existing configuration.

LLMEvaluator

LLMEvaluator is an option for functions such as LLMSynthesize that specifies the LLM configuration.

LLMExampleFunction

LLMExampleFunction[{in1->out1,in2->out2,…}] creates an LLMFunction from few-shot examples.

LLMExampleFunction[{in1,in2,…}->{out1,out2,…}] generates the same result.

LLMExampleFunction[{header,training}] prefaces the prompt with header.

LLMExampleFunction[prompting,form] includes the interpreter form to apply to the response.

LLMFunction

LLMFunction[prompt] represents a template for a large language model (LLM) prompt.

LLMFunction[{prompt1,prompt2,…}] represents a combination of multiple prompts.

LLMFunction[prompt,form] includes the interpreter form to apply to the response.

LLMFunction[…][params] give the LLM service response for prompt applied to parameters params.

LLMPrompt

LLMPrompt["name"] gives the TemplateObject for the specified large language model prompt.

LLMPrompt[resource] retrieves the TemplateObject for the specified resource.

LLMPrompt[…,params] gives the TemplateObject with slots filled in by params.

LLMPrompt[…][p1,p2,…] applies a template with numbered slots to parameter values pi.

LLMPrompt[…][<|key1->p1,key2->p2|>] applies a template with named slots to parameter data.

LLMPromptGenerator

LLMPromptGenerator[f] represents a prompt generator that uses the function f.

LLMPromptGenerator[f,inputspec] provides the specified inputspec to f.

LLMResourceFunction

LLMResourceFunction["name"] retrieves an LLMFunction with the specified name.

LLMResourceFunction[loc] imports an LLMFunction from the specified location.

LLMResourceFunction[…][params] applies the specified LLMFunction to the parameters params.

LLMSynthesize

LLMSynthesize[prompt] generates text according to the input prompt.

LLMSynthesize[{prompt1,…}] combines multiple prompti together.

LLMSynthesize[…,prop] returns the specified property of the generated text.

LoadCompiledComponent

LoadCompiledComponent[comp] loads a compiled component comp.

LoadCompiledComponent[comp,target] loads a compiled component comp from the target location.

LocalEvaluate

LocalEvaluate[expr] gives the result of evaluating expr using your current default local Wolfram Language kernel.

LocalEvaluate[ker, expr] gives the result of evaluating expr using the kernel specified by ker.

LocalEvaluate[{ker1,ker2,…},expr] gives a list of the results of evaluating expr using each of the kernels keri.

LocalEvaluate[ker,expr,h] wraps the head h around the result produced before returning it.

LowerTriangularMatrix

LowerTriangularMatrix[lmat] converts the lower triangular matrix lmat to a structured array.

LunationNumber

LunationNumber[] returns the number of new moons since the first new moon of the year 2000.

LunationNumber[date] returns the number of new moons since the given date.

LunationNumber[scheme,date] returns the number of new moons since the zeroth new moon of the given counting scheme.

MapApply

f@@@expr or MapApply[f,expr] replaces heads at level 1 of expr by f.

MapApply[f] represents an operator form of MapApply that can be applied to an expression.

MatrixSymbol

MatrixSymbol[a] represents a matrix with name a.

MatrixSymbol[a,{m,n}] represents an mn matrix.

MatrixSymbol[a,{m,n},dom] represents a matrix with elements in the domain dom.

MatrixSymbol[a,{m,n},dom, sym] represents a matrix with the symmetry sym.

MaxRoots

MaxRoots is an option for NSolve and related functions that specifies the maximum number of roots that should be returned in the solution for a system of algebraic or transcendental equations.

MinSize

MinSize is an option of certain BoxForm primitives.

ModelPredictiveController

ModelPredictiveController[sspec,cost,cons] computes the model predictive controller for the system specification sspec that minimizes the cost function cost and satisfies the constraints cons.

ModelPredictiveController[…,"prop"] returns the value of the property "prop".

MoonPhaseDate

MoonPhaseDate[] returns the date of the next new moon.

MoonPhaseDate[phase] returns the date of the next instance of the given phase of the Moon.

MoonPhaseDate[date,phase] returns the date for the first instance of the given phase after date.

NCaputoD

NCaputoD[f,{x,α},x0] gives a numerical approximation to the Caputo fractional derivative C0Dxαf(x) of order α of the function f at the point x0.

NContourIntegrate

NContourIntegrate[f,z∈cont] gives the numerical integral of f along the contour defined by cont in the complex plane.

NetExternalObject

NetExternalObject[…] represents a net model in an external framework format.

NewMoon

NewMoon[] gives the date of the next new moon.

NewMoon[date] gives the date of the first new moon after the given date.

NLineIntegrate

NLineIntegrate[f,{x,y,…}∈curve] computes the numerical scalar line integral of the function f[x,y,…] over the curve.

NLineIntegrate[{p,q,…},{x,y,…}∈curve] computes the numerical vector line integral of the vector function {p[x,y,…],q[x,y,…],…}.

NominalScale

NominalScale[{cat1,cat2,…,catn}] represents a set of unordered categories cati. 

NominalScale[<|cat1->lab1,…,catn->labn|>] also associates the category cati with the labels labi.

NominalScale[…,<|cati->labi,…|>] uses labi to represent cati in plots.

NominalScale[Automatic] automatically determines the categories.

NoneMatch

NoneMatch[{e1,e2,…},form] yields True if ei does not match the pattern form for any of the ei.

NoneMatch[expr,form,level] tests parts of expr at level level.

NoneMatch[form] represents an operator form of NoneMatch that can be applied to an expression.

NonThreadable

NonThreadable is an attribute that can be assigned to a symbol f to indicate that f and f[arg1,arg2,…] should not combine with other list arguments in arithmetic and many other functions that work with lists.

NSurfaceIntegrate

NSurfaceIntegrate[f,{x,y,…}∈surface] computes the numerical scalar surface integral of the function f[x,y,…] over the surface.

NSurfaceIntegrate[{p,q,…},{x,y,…}∈surface] computes the numerical vector surface integral of the vector field {p[x,y,…],q[x,y,…],…}.

NullRawPointerQ

NullRawPointerQ[ptr] gives True if ptr is a null pointer, and False otherwise.

OpaqueRawPointer

OpaqueRawPointer[addr] represents an untyped pointer to the memory address addr.

OperationDeclaration

OperationDeclaration[type,op,typedfun] declares a typed function to be used for the operation op of type.

OrdinalScale

OrdinalScale[{cat1,cat2,…,catn}] represents a set of ordered categories cati with order cat1<cat2<…<catn.

OrdinalScale[{cat1,…,catn},{val1,…,valn}] associates the category cati with the numeric value vali.

OrdinalScale[<|cat1->val1,…,catn->valn|>] also associates the category cati with the numeric value vali.

OrdinalScale[{cat1,…,catn},vals,{lab1,…,labn}] displays the category cati as the corresponding labi when used as a label in plots etc.

OrdinalScale[…,<|cati->labi,…|>] uses labi to represent cati in plots.

OrthogonalMatrix

OrthogonalMatrix[omat] converts the orthogonal matrix omat to a structured array.

PairwiseDensityHistogram

PairwiseDensityHistogram[{{y11,…,y1n},…,{ym1,…,ymn}}] creates an array of density histograms by plotting the data columns against each other in pairs.

PairwiseDensityHistogram[data,bpsec] plots density histograms with bins specified by bspec.

PairwiseListPlot

PairwiseListPlot[{{y11,…,y1n},…,{ym1,…,ymn}}] creates an array of scatter plots by plotting the data columns against each other in pairs.

PairwiseListPlot[{data1,data2,…}] plots multiple sets of data in each plot panel.

PairwiseProbabilityPlot

PairwiseProbabilityPlot[{{y11,…,y1n},…,{ym1,…,ymn}}] plots a CDF of columns in the data against each other.

PairwiseQuantilePlot

PairwiseQuantilePlot[{{y11,…,y1n},…,{ym1,…,ymn}}] creates an array of quantile plots by plotting the quantiles of the columns against each other.

PairwiseSmoothDensityHistogram

PairwiseSmoothDensityHistogram[{{y11,…,y1n},…,{ym1,…,ymn}}] creates an array of smooth density histograms by plotting the data columns against each other in pairs.

ParentEdgeLabel

ParentEdgeLabel is an option for Tree and related functions that specifies what labels should be used for edges.

ParentEdgeLabelFunction

ParentEdgeLabelFunction is an option for Tree and related functions that specifies functions to use to generate edge labels.

ParentEdgeShapeFunction

ParentEdgeShapeFunction is an option for Tree and related functions that specifies a function to use to generate primitives for rendering edges.

PascalBinomial

PascalBinomial[n,m] gives the binomial coefficient (�) that preserves Pascal's identity.

PermutationMatrix

PermutationMatrix[permv] represents the permutation matrix given by permutation vector permv as a structured array.

PermutationMatrix[pmat] converts a permutation matrix pmat to a structured array. 

PhongShading

PhongShading[] is a three‐dimensional graphics directive that specifies that faces of polygons and other filled graphics objects are to be drawn to reflect as a smooth surface using a normal‐vector interpolation shading.

PhongShading[d] uses the attenuation factor d for the diffuse light.

PhongShading[d,s] uses the attenuation factor s for the specular light.

PhongShading[d,s,a] uses the attenuation factor a for the ambient light.

PlotHighlighting

PlotHighlighting is an option to Plot, ListPlot and related visualization functions that specifies how points and curves should be highlighted. 

PolarCurve

PolarCurve[r,{θ,θmin,θmax}] gives a polar curve with radius r as a function of angle θ.

PositionLargest

PositionLargest[list] gives the positions of the numerically largest value in list.

PositionLargest[list,n] gives the positions of the first n largest values.

PositionLargest[list,n,orderfun] gives the positions of the n largest values in list as determined by orderfun.

PositionSmallest

PositionSmallest[list] gives the positions of the numerically smallest value in list.

PositionSmallest[list,n] gives the positions of the first n smallest values.

PositionSmallest[list,n,orderfun] gives the positions of the n smallest values in list as determined by orderfun.

PropagateAborts

PropagateAborts is an option to CheckAbort to control whether a handled abort propagates to the enclosing function.

QuestionGenerator

QuestionGenerator[<|name1:>val1,name2:>val2,…|>, genfunc] represents a QuestionObject generated by applying genfunc to <|name1:>val1,name1:>val2,…|>.

QuestionGenerator[CloudObject[…]] represents a cloud-deployed question generator.

QuestionSelector

QuestionSelector[{qo1,qo2,…}] represents a list of questions from which one of the question objects qoi can be randomly selected.

QuestionSelector[CloudObject[…]] represents a cloud-deployed question selector.

RandomDate

RandomDate[] gives a pseudorandom date in the current calendar year.

RandomDate[{datemin,datemax}] gives a pseudorandom date between the dates datemin and datemax.

RandomDate[date] gives a pseudorandom date between the start and end of the calendar period date.

RandomDate[quantity] gives a pseudorandom date between now and the time quantity duration from now.

RandomDate[range,n] gives a list of n pseudorandom dates.

RandomTime

RandomTime[] gives a pseudorandom time of day.

RandomTime[{timemin,timemax}] gives a pseudorandom time between the times timemin and timemax.

RandomTime[time] gives a pseudorandom times between the start and end of the time period time.

RandomTime[quantity] gives a pseudorandom time between now and the time quantity duration from now.

RandomTime[range,n] gives a list of n pseudorandom times.

RawMemoryAllocate

RawMemoryAllocate[type] allocates enough raw memory to store a binary representation of the specified type.

RawMemoryAllocate[type,len] allocates memory for len objects.

RawMemoryExport

RawMemoryExport[expr] exports a raw memory representation of expr.

RawMemoryExport[expr,type] uses the specified element type when returning an array.

RawMemoryFree

RawMemoryFree[ptr] frees the raw memory at a pointer ptr.

RawMemoryImport

RawMemoryImport[ptr,format] imports raw memory from the pointer ptr with the specified format.

RawMemoryImport[format] represents an operator form of RawMemoryImport that can be applied to an expression.

RawMemoryRead

RawMemoryRead[ptr] reads raw memory from the pointer ptr.

RawMemoryRead[ptr,offset] reads from an offset pointer.

RawMemoryWrite

RawMemoryWrite[ptr,val] writes a binary representation of val to the raw memory at the pointer ptr.

RawMemoryWrite[ptr,val,offset] writes to an offset pointer.

RawPointer

RawPointer[addr,type] represents a raw pointer to the specified type at the memory address addr.

RealValuedNumberQ

RealValuedNumberQ[expr] returns True if expr is a number with a real value and False otherwise.

RealValuedNumericQ

RealValuedNumericQ[expr] gives True if expr is a real-valued numeric quantity, and False otherwise.

ReapVideo

ReapVideo[expr] gives a video whose frames are the expressions to which SowVideo has been applied during its evaluation.

ReconstructionMesh

ReconstructionMesh[{pt1,pt2,…}] reconstructs a mesh from a set of points pt1,pt2,….

RegionFarthestDistance

RegionFarthestDistance[reg1,reg2] gives the farthest distance between points in the regions reg1 and reg2.

RegionHausdorffDistance

RegionHausdorffDistance[reg1,reg2] gives the Hausdorff distance between the regions reg1 and reg2.

ReplaceAt

ReplaceAt[expr,rules,n] transforms expr by replacing the nth element using rules.

ReplaceAt[expr,rules,{i,j,…}] replaces the part of expr at position {i,j,…}.

ReplaceAt[expr,rules,{{i1,j1,…},{i2,j2,…},…}] replaces parts at several positions.

ReplaceAt[rules,pos] represents an operator form of ReplaceAt that can be applied to an expression.

ResidueSum

ResidueSum[f,z] finds the sum of residues of the meromorphic function f with the variable z.

ResidueSum[{f,cons},z] finds the sum of residues of f within the solution set of the constraints cons. 

RFixedPoints

RFixedPoints[eqn,a[n],n] gives the fixed points for a recurrence equation.

RFixedPoints[{eqn1,eqn2,…},{a1[n],a2[n],…},n] gives the fixed points for a system of recurrence equations.

RootTree

RootTree[tree] returns the root node of tree as a Tree object.

RootTree[tree,n] returns a Tree object containing the nodes of tree down to level n.

RStabilityConditions

RStabilityConditions[eqn,a[n],n] gives the fixed points and stability conditions for a recurrence equation.

RStabilityConditions[{eqn1,eqn2,…},{a1[n],a2[n],…},n] gives the fixed points and stability conditions for a system of recurrence equations.

RStabilityConditions[{eqn1,eqn2,…},{a1[n],a2[n],…},n,{pnt1,pnt2,…}] gives stability conditions only for the given fixed points.

SameAs

SameAs[y] is an operator form that yields x===y when applied to an expression x.

SamplerModel

SamplerModel[] represents the single-input, single-output model of a sampler.

SamplerModel[specs] represents a sampler with specification specs.

SchrodingerPDEComponent

SchrodingerPDEComponent[vars,pars] yields a Schrödinger PDE term with model variables vars and model parameters pars. 

SecDegrees

SecDegrees[θ] gives the secant of θ degrees. 

SemanticSearch

SemanticSearch[index,query] finds the items similar to query inside index.

SemanticSearch[index,query->f] filters the results using the function f.

SemanticSearch[index,query,prop] returns the specified property prop.

SemanticSearchIndex

SemanticSearchIndex[…] represents a semantic search index object.

SemanticSearchIndex[source] attempts to recreate a SemanticSearchIndex from source.

SemanticSearchIndices

SemanticSearchIndices[] returns a list with all the known instances of SemanticSearchIndex.

SemanticSearchIndices[patt] returns a list of indices with the name matching the pattern patt.

SequenceType

SequenceType[var] represents a type parameterized by var that refers to a sequence of zero or more types.

ShowContents

ShowContents is an option for selections that specifies whether an object represented by a StyleBox should be displayed on the screen or replaced by blank space.

SinDegrees

SinDegrees[θ] gives the sine of θ degrees. 

SowVideo

SowVideo[frame] specifies that frame should be collected by the nearest enclosing ReapVideo.

SowVideo[frame,n] repeats frame n times when reaped.

SpellingOptions

SpellingOptions is an option for notebooks that specifies settings for spellchecking.

SphericalAngle

SphericalAngle[{θ0,ϕ0}->{{θ1,ϕ1},{θ2,ϕ2}}] gives the signed angle in radians between the great circles through point {θ0,ϕ0} and points {θ1,ϕ1} and {θ2,ϕ2}.

SphericalAngle[p->{q,r}] gives the unsigned angle for points p, q, r of the form {θ1,θ2,…,θn-1,ϕ} on an n-dimensional hypersphere.

SphericalAngle[p->{{q1,r1},…,{qn,rn}}] gives a list of angles between the great circles from point p through points qi and ri.

SphericalAngle[{p1,…,pn}->{{q1,r1},…,{qn,rn}}] gives a list of angles between the great circles from point pi through points qi and ri.

SphericalDistance

SphericalDistance[{θ1,ϕ1},{θ2,ϕ2}] returns the great-circle distance between points {θ1,ϕ1} and {θ2,ϕ2} on the surface of a unit sphere. 

SphericalDistance[{θ1,1,θ1,2,…,ϕ1},{θ2,1,θ2,2,…,ϕ2}] returns the geodesic distance between arbitrary-dimensional points on the surface of a unit hypersphere. 

Squiggled

Squiggled[expr] displays expr with text underlined with a squiggly red underline.

Squiggled[expr,color] displays squiggly using the specified color.

StatusArea

StatusArea[expr,string] displays string in the status area of the current notebook when the mouse pointer is in the region where expr appears. 

StringApply

StringApply[f,string] applies f to the code points in string.

StringApply[f] represents an operator form of StringApply that can be applied to an expression.

Struckthrough

Struckthrough represents a font with a strike-through line.

SurdForm

SurdForm is an option to RadicalBox and SqrtBox that indicates whether the radical represents a Surd expression.

SurfaceIntegrate

SurfaceIntegrate[f,{x,y,…}∈surface] computes the scalar surface integral of the function f[x,y,…] over the surface.

SurfaceIntegrate[{p,q,…},{x,y,…}∈surface] computes the vector surface integral of the vector field {p[x,y,…],q[x,y,…],…}.

SymbolicDeltaProductArray

SymbolicDeltaProductArray[{n1,n2,…},{{j1,1,j1,2,…},{j2,1,j2,2,…},…}] represents an n1×n2×… array with elements ai1,i2,… equal to 1 if all ijp,1ijp,2…, and 0 otherwise.

SymbolicIdentityArray

SymbolicIdentityArray[{n1,n2,…}] represents an n1×n2×…×n1×n2×… array with elements ai1,i2,…,j1,j2,… equal to 1 if all ikjk, and 0 otherwise.

SymbolicOnesArray

SymbolicOnesArray[] represents an array of ones with unspecified dimensions.

SymbolicOnesArray[{n1,n2,…}] represents an n1×n2×… array of ones.

SymbolicZerosArray

SymbolicZerosArray[] represents an array of zeros with unspecified dimensions.

SymbolicZerosArray[{n1,n2,…}] represents an n1×n2×… array of zeros.

SymmetricDifference

SymmetricDifference[list1,list2,…] gives the symmetric difference of the lists listi.

SymmetricMatrix

SymmetricMatrix[smat] converts the symmetric matrix smat to a structured array.

TanDegrees

TanDegrees[θ] gives the tangent of θ degrees. 

TargetStructure

TargetStructure is an option for linear algebra functions that specifies the representation of the result produced by the function.

TerminatedEvaluation

TerminatedEvaluation["reason"] represents an expression whose evaluation overran global kernel session limits and was terminated.

TernaryListPlot

TernaryListPlot[{{u1,v1,w1},…,{un,vn,wn}}] plots a list of points with specified u, v and w coordinates in a barycentric coordinate system.

TernaryListPlot[{data1,data2,…}] plots a ternary plot with several datasets datai.

TernaryPlotCorners

TernaryPlotCorners is an option for TernaryListPlot that determines how the triangle and axes are positioned.

Threaded

Threaded[list] is an object whose elements will automatically be threaded into the lowest level of an array when used in a listable operation such as Plus.

a+Threaded[b] adds elements of an array b to elements of an array a at the lowest possible level.

a+Threaded[b,alev] adds elements at level alev of a.

a+Threaded[b,blev->alev] adds elements at level alev in a to level blev in b.

f[a,Threaded[b,…]] combines elements for a function f with the attribute Listable.

TimeDistribution

TimeDistribution[dist,tunit] represents a linear distribution of time of day according to dist with time scale unit tunit originating at midnight.

TimeDistribution[dist, tunit, torig] represents a linear distribution of time of day with time origin at torig.

ToFiniteField

ToFiniteField[k,ff] converts the integer k to an element of the prime subfield of the finite field ff.

ToFiniteField[expr,ff] converts the coefficients of the rational expression expr to elements of the finite field ff.

ToFiniteField[expr,ff,t] converts the coefficients of the rational expression expr to elements of the finite field ff, with t representing the field generator.

ToRawPointer

ToRawPointer[] creates a new pointer object in compiled code, suitable for use with external libraries.

ToRawPointer[val] creates a new object pointing to the initial value val.

ToRawPointer[p,val] stores val in the pointer p.

ToRawPointer[array,offset,val] stores val in the "CArray" array at the given offset.

TorusGraph

TorusGraph[{n1,n2,…,nk}] gives the k-dimensional torus graph with n1×n2×…×nk vertices.

Tour3DVideo

Tour3DVideo[g] generates a video giving a standard tour around a 3D object g. 

Tour3DVideo[g,tour] generates the named video tour.

Tour3DVideo[g,steps] generates a video tour from steps. 

TreeElementCoordinates

TreeElementCoordinates is an option for Tree and related functions that specifies the coordinates to use to place the center of subtree elements.

TreeElementLabelFunction

TreeElementLabelFunction is an option for Tree and related functions that specifies functions to use to generate subtree element labels.

TreeElementShape

TreeElementShape is an option for Tree and related functions that specifies what graphics should be used for subtree elements.

TreeElementShapeFunction

TreeElementShapeFunction is an option for Tree and related functions that specifies a function to use to generate primitives for rendering subtree elements.

TreeElementSize

TreeElementSize is an option for Tree and related functions that specifies what size should be used for subtree elements.

TreeElementSizeFunction

TreeElementSizeFunction is an option for Tree and related functions that specifies a function to use to generate sizes for subtree elements.

TreeLeafCount

TreeLeafCount[tree] gives the number of leaves of tree.

TruncateSum

TruncateSum[sexpr,n] truncates each Sum in sexpr to have at most n terms. 

TruncateSum[sexpr,{m,n,…}] truncates each multiple Sum in sexpr using the iterative specification {m,n,…}.

TypeEvaluate

TypeEvaluate[expr] represents a type created by evaluating expr.

TypeHint

TypeHint[expr,type] represents an expression of a specified type when compiled and gives expr when evaluated.

TypeOf

TypeOf[expr] gives the type of expr without evaluating it.

TypeOf[expr,Typed[x,ty]] assumes that instances of x in expr have type ty.

TypeOf[expr,{Typed[x1,ty1],Typed[x2,ty2],…}] assumes that xi has type tyi.

TypeOf[expr,decls] uses declarations decls.

UnilateralConvolve

UnilateralConvolve[f,g,u,t] gives the unilateral convolution with respect to u of the expressions f and g.

UnilateralConvolve[f,g,{u1,…,un},{t1,…,tn}] gives the multidimensional unilateral convolution.

UnilateralDiscreteConvolve

UnilateralDiscreteConvolve[f,g,k,n] gives the unilateral discrete convolution with respect to k of the expressions f and g.

UnilateralDiscreteConvolve[f,g,{k1,…,kp},{n1,…,np}] gives the multidimensional unilateral discrete convolution.

UniqueElements

UniqueElements[{list1,list2,…}] gives the elements for each listi that are not in any other list.

UniqueElements[lists,test] uses test to determine whether pairs of elements should be considered equivalent.

UnitaryMatrix

UnitaryMatrix[umat] converts the unitary matrix umat to a structured array.

UnlabeledTree

UnlabeledTree[tree] returns a tree of the same shape as tree in which the nodes and edges are displayed without labels.

UnmanageObject

UnmanageObject[man] takes ownership of memory wrapped in a managed object.

Until

Until[test,body] evaluates body and then test, repetitively, until test first gives True.

UpdateSemanticSearchIndex

UpdateSemanticSearchIndex[index,source] updates the SemanticSearchIndex[…] index with the data in source.

UpdateSemanticSearchIndex[index,{source1, …}] updates the SemanticSearchIndex[…] index with the collection of sources sourcei.

UpdateSemanticSearchIndex[index,{source1 -> val1, …}] associates the new source sourcei to the value vali.

UpperTriangularMatrix

UpperTriangularMatrix[umat] converts the upper triangular matrix umat to a structured array.

VandermondeMatrix

VandermondeMatrix[{x1,x2,…,xn}] gives an n×n Vandermonde matrix corresponding to the nodes xi.

VandermondeMatrix[{x1,x2,…,xn},k] gives an n×k Vandermonde matrix.

VandermondeMatrix[vmat] converts a Vandermonde matrix vmat to a structured array. 

VectorSymbol

VectorSymbol[v] represents a vector with name v.

VectorSymbol[v,d] represents a vector of length d.

VectorSymbol[v,d,dom] represents a vector with elements in the domain dom.

VideoExtractTracks

VideoExtractTracks[video] returns a list of video, audio and subtitle tracks of video.

VideoExtractTracks[video,"type"] returns tracks from video of a given "type".

VideoExtractTracks[video,trackspec] returns tracks specified by trackspec.

VideoFrameFold

VideoFrameFold[f,img0,video] gives a video whose frames are {f[img0,img1], f[f[img0,img1],img2],…}, where imgi are frames of video.

VideoFrameFold[f,video] assumes the first frame to be the initial frame.

VideoFrameFold[f,img0,video,n] uses partitions of n frames of the video for each step.

VideoFrameFold[f,img0,video,n,d] uses partitions of n frames with offset of d frames for each step.

VideoPadding

VideoPadding is an option for GridVideo and other video functions to specify how to pad video frames when input videos have different durations.

VideoSummaryPlot

VideoSummaryPlot[video] plots a summary of video and audio tracks of video.

VideoSummaryPlot[video,layout] lays out the video frames according to the provided layout.

VideoTranscribe

VideoTranscribe[video] recognizes speech in an audio track and adds it to video as a subtitle track.